diff --git a/README.md b/README.md
index 933bbf1..3fa0dfa 100644
--- a/README.md
+++ b/README.md
@@ -348,7 +348,7 @@ Lossless *and* cheap is easy to get wrong. A few things that make it hold:
 | `secondwind check` | verify the install and agent integration |
 | `secondwind optimize <file>` | compress one tool-output block and print the result |
 | `secondwind verify <wire> <cert>` | re-check a compressed wire against its fidelity certificate |
-| `secondwind eval` | replay your recorded sessions through the optimizer: tokens sent, reopens, net savings and faithfulness per tool and command |
+| `secondwind eval` | replay your recorded sessions through the optimizer: tokens sent, reopens, net savings and faithfulness per tool and command (`--learn` fits the reopen gate to your history) |
 | `secondwind exec -- <cmd>` | compress one command's output, shell-filter style (`-c '<script>'` runs a shell string) |
 | `secondwind` (no args) | audit what optimization did to your existing sessions |
 
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index b30eac3..c8e5e2c 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -109,6 +109,17 @@ enum Command {
             help = "Also write one JSON line per tool result"
         )]
         blocks: Option<PathBuf>,
+        #[arg(
+            long,
+            help = "Replay with the reopen gate the optimizer applies (learned table, else built-in)"
+        )]
+        gate: bool,
+        #[arg(
+            long,
+            conflicts_with_all = ["gate", "blocks"],
+            help = "Fit reopen rates on half the sessions, show the gate on the other half, write ~/.secondwind/policy.json"
+        )]
+        learn: bool,
     },
     #[command(
         about = "Estimate the tokens the optimizer would remove across your discovered traffic"
@@ -309,7 +320,12 @@ fn main() -> ExitCode {
         }) => return optimize(&input, tokens, prose),
         Some(Command::Verify { wire, certificate }) => return verify(&wire, &certificate),
         Some(Command::ReopenRate { limit }) => return reopen_rate(&home, limit),
-        Some(Command::Eval { limit, blocks }) => return eval(&home, limit, blocks.as_deref()),
+        Some(Command::Eval {
+            limit,
+            blocks,
+            gate,
+            learn,
+        }) => return eval(&home, limit, blocks.as_deref(), gate, learn),
         Some(Command::CacheSavings { limit }) => return cache_savings(&home, limit),
         Some(Command::Exec { script, command }) => {
             return exec(&home, script.as_deref(), &command);
@@ -799,69 +815,83 @@ fn verify(wire: &PathBuf, certificate: &str) -> ExitCode {
 }
 
 // Net assumes a reopened offload is fetched back whole, the costliest case; a slice costs less.
-fn eval(home: &Path, limit: usize, blocks: Option<&Path>) -> ExitCode {
-    use secondwind_optimize::counterfactual::{BlockOutcome, evaluate};
-    use std::io::Write;
+#[derive(Default)]
+struct Tally {
+    sessions: u64,
+    blocks: u64,
+    inline: u64,
+    offload: u64,
+    reopened: u64,
+    raw: u64,
+    sent: u64,
+    back: u64,
+    unfaithful: u64,
+}
 
-    #[derive(Default)]
-    struct Tally {
-        blocks: u64,
-        inline: u64,
-        offload: u64,
-        reopened: u64,
-        raw: u64,
-        sent: u64,
-        back: u64,
-        unfaithful: u64,
-    }
-    impl Tally {
-        fn add(&mut self, b: &BlockOutcome) {
-            self.blocks += 1;
-            if !b.faithful {
-                self.unfaithful += 1;
-            }
-            self.raw += b.raw_tokens;
-            self.sent += b.sent_tokens;
-            match b.outcome {
-                "inline" => self.inline += 1,
-                "offload" => self.offload += 1,
-                _ => {}
-            }
-            if b.reopened {
-                self.reopened += 1;
-                self.back += b.raw_tokens;
-            }
+impl Tally {
+    fn add(&mut self, b: &secondwind_optimize::counterfactual::BlockOutcome) {
+        self.blocks += 1;
+        self.unfaithful += u64::from(!b.faithful);
+        self.raw += b.raw_tokens;
+        self.sent += b.sent_tokens;
+        match b.outcome {
+            "inline" => self.inline += 1,
+            "offload" => self.offload += 1,
+            _ => {}
         }
-        fn json(&self) -> serde_json::Value {
-            let net = self.raw as i64 - self.sent as i64 - self.back as i64;
-            let ratio = |a: f64, b: u64| if b == 0 { 0.0 } else { a / b as f64 };
-            serde_json::json!({
-                "blocks": self.blocks,
-                "inline": self.inline,
-                "offloaded": self.offload,
-                "reopened": self.reopened,
-                "reopen_rate": ratio(self.reopened as f64, self.offload),
-                "raw_tokens": self.raw,
-                "sent_tokens": self.sent,
-                "back_tokens": self.back,
-                "net_tokens": net,
-                "net_share": ratio(net as f64, self.raw),
-                "unfaithful": self.unfaithful,
-            })
+        if b.reopened {
+            self.reopened += 1;
+            self.back += b.raw_tokens;
         }
     }
 
+    fn json(&self) -> serde_json::Value {
+        let net = self.raw as i64 - self.sent as i64 - self.back as i64;
+        let ratio = |a: f64, b: u64| if b == 0 { 0.0 } else { a / b as f64 };
+        serde_json::json!({
+            "blocks": self.blocks,
+            "inline": self.inline,
+            "offloaded": self.offload,
+            "reopened": self.reopened,
+            "reopen_rate": ratio(self.reopened as f64, self.offload),
+            "reopens_per_session": ratio(self.reopened as f64, self.sessions),
+            "raw_tokens": self.raw,
+            "sent_tokens": self.sent,
+            "back_tokens": self.back,
+            "net_tokens": net,
+            "net_share": ratio(net as f64, self.raw),
+            "unfaithful": self.unfaithful,
+        })
+    }
+}
+
+fn policy_path(home: &Path) -> PathBuf {
+    home.join(".secondwind").join("policy.json")
+}
+
+// The policy the optimizer applies: the table `eval --learn` fitted, else the built-in one.
+fn reopen_policy(home: &Path) -> (secondwind_optimize::policy::ReopenPolicy, &'static str) {
+    use secondwind_optimize::policy::ReopenPolicy;
+    match std::fs::read_to_string(policy_path(home))
+        .ok()
+        .and_then(|text| ReopenPolicy::from_json(&text))
+    {
+        Some(policy) => (policy, "learned"),
+        None => (ReopenPolicy::builtin(), "built-in"),
+    }
+}
+
+// Every discovered trace in a stable order, numbered from 1; `each` gets the blocks of the traces
+// `only` admits. Returns the number of files read.
+fn replay(
+    home: &Path,
+    limit: usize,
+    gate: Option<&secondwind_optimize::policy::ReopenPolicy>,
+    only: impl Fn(usize) -> bool,
+    mut each: impl FnMut(usize, Vec<secondwind_optimize::counterfactual::BlockOutcome>),
+) -> usize {
     let counter = std::sync::Arc::new(secondwind_optimize::tokens::Tiktoken::cl100k());
-    let mut dump = match blocks.map(std::fs::File::create).transpose() {
-        Ok(file) => file.map(std::io::BufWriter::new),
-        Err(err) => {
-            eprintln!("secondwind eval: {err}");
-            return ExitCode::FAILURE;
-        }
-    };
     let model = configured_model();
-    let mut total = Tally::default();
-    let mut by_class: BTreeMap<String, Tally> = BTreeMap::new();
     let mut files_read = 0usize;
     let mut traces = 0usize;
     for source in secondwind_sources::all() {
@@ -878,27 +908,65 @@ fn eval(home: &Path, limit: usize, blocks: Option<&Path>) -> ExitCode {
             files_read += 1;
             for trace in &outcome.traces {
                 traces += 1;
+                if !only(traces) {
+                    continue;
+                }
                 let mut optimizer = secondwind_optimize::Optimizer::default()
                     .with_counter(counter.clone())
                     .with_model(&model);
-                for block in evaluate(trace, &mut optimizer, counter.as_ref()) {
-                    total.add(&block);
-                    by_class.entry(block.class.clone()).or_default().add(&block);
-                    if let Some(out) = dump.as_mut() {
-                        let line = serde_json::json!({
-                            "trace": traces, "turn": block.turn, "tool": block.tool,
-                            "class": block.class, "shape": block.shape,
-                            "outcome": block.outcome, "bytes": block.raw_bytes,
-                            "raw": block.raw_tokens, "sent": block.sent_tokens,
-                            "reopened": block.reopened, "faithful": block.faithful,
-                            "ctx": block.context_tokens, "after": block.turns_after,
-                        });
-                        let _ = writeln!(out, "{line}");
-                    }
-                }
+                let blocks = secondwind_optimize::counterfactual::evaluate(
+                    trace,
+                    &mut optimizer,
+                    counter.as_ref(),
+                    gate,
+                );
+                each(traces, blocks);
             }
         }
     }
+    files_read
+}
+
+fn eval(home: &Path, limit: usize, blocks: Option<&Path>, gate: bool, learn: bool) -> ExitCode {
+    use std::io::Write;
+
+    if learn {
+        return eval_learn(home, limit);
+    }
+    let mut dump = match blocks.map(std::fs::File::create).transpose() {
+        Ok(file) => file.map(std::io::BufWriter::new),
+        Err(err) => {
+            eprintln!("secondwind eval: {err}");
+            return ExitCode::FAILURE;
+        }
+    };
+    let (policy, source) = reopen_policy(home);
+    let mut total = Tally::default();
+    let mut by_class: BTreeMap<String, Tally> = BTreeMap::new();
+    let files_read = replay(
+        home,
+        limit,
+        gate.then_some(&policy),
+        |_| true,
+        |trace, outcomes| {
+            total.sessions += 1;
+            for block in outcomes {
+                total.add(&block);
+                by_class.entry(block.class.clone()).or_default().add(&block);
+                if let Some(out) = dump.as_mut() {
+                    let line = serde_json::json!({
+                        "trace": trace, "turn": block.turn, "tool": block.tool,
+                        "class": block.class, "shape": block.shape,
+                        "outcome": block.outcome, "bytes": block.raw_bytes,
+                        "raw": block.raw_tokens, "sent": block.sent_tokens,
+                        "reopened": block.reopened, "faithful": block.faithful,
+                        "ctx": block.context_tokens, "after": block.turns_after,
+                    });
+                    let _ = writeln!(out, "{line}");
+                }
+            }
+        },
+    );
 
     let mut classes: Vec<_> = by_class.into_iter().collect();
     classes.sort_by_key(|(_, t)| std::cmp::Reverse(t.raw));
@@ -912,6 +980,7 @@ fn eval(home: &Path, limit: usize, blocks: Option<&Path>) -> ExitCode {
         .collect();
     let result = serde_json::json!({
         "files_read": files_read,
+        "gate": if gate { source } else { "off" },
         "total": total.json(),
         "by_class": by_class,
     });
@@ -922,6 +991,69 @@ fn eval(home: &Path, limit: usize, blocks: Option<&Path>) -> ExitCode {
     ExitCode::SUCCESS
 }
 
+// Fits reopen rates on the even-numbered sessions, replays the odd ones with and without the gate,
+// and writes the table only after showing what it does on sessions it never saw.
+fn eval_learn(home: &Path, limit: usize) -> ExitCode {
+    use secondwind_optimize::policy::ReopenPolicy;
+
+    let mut learned_from = Vec::new();
+    let mut without = Tally::default();
+    replay(
+        home,
+        limit,
+        None,
+        |_| true,
+        |trace, outcomes| {
+            if trace % 2 == 0 {
+                learned_from.extend(outcomes);
+            } else {
+                without.sessions += 1;
+                outcomes.iter().for_each(|b| without.add(b));
+            }
+        },
+    );
+    let policy = ReopenPolicy::learn(&learned_from, 30);
+    let mut with = Tally::default();
+    replay(
+        home,
+        limit,
+        Some(&policy),
+        |trace| trace % 2 == 1,
+        |_, outcomes| {
+            with.sessions += 1;
+            outcomes.iter().for_each(|b| with.add(b));
+        },
+    );
+
+    let path = policy_path(home);
+    let written = path
+        .parent()
+        .map(std::fs::create_dir_all)
+        .transpose()
+        .and_then(|_| {
+            std::fs::write(
+                &path,
+                serde_json::to_string_pretty(&policy).unwrap_or_default(),
+            )
+        });
+    if let Err(err) = written {
+        eprintln!("secondwind eval: {}: {err}", path.display());
+        return ExitCode::FAILURE;
+    }
+    let result = serde_json::json!({
+        "policy": path.display().to_string(),
+        "threshold": policy.threshold,
+        "classes": policy.classes.len(),
+        "learned_from_offloads": learned_from.iter().filter(|b| b.outcome == "offload").count(),
+        "held_out": { "without_gate": without.json(), "with_gate": with.json() },
+    });
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&result).unwrap_or_default()
+    );
+    ExitCode::SUCCESS
+}
+
 fn reopen_rate(home: &Path, limit: usize) -> ExitCode {
     use secondwind_optimize::counterfactual::{ReopenStats, measure};
 
@@ -1110,6 +1242,17 @@ fn exec(home: &Path, script: Option<&str>, argv: &[String]) -> ExitCode {
             proxy::store_dir(home),
             proxy::OFFLOAD_TTL,
         ));
+    let shown = script.map_or_else(|| argv.join(" "), str::to_string);
+    let class = secondwind_optimize::counterfactual::command_class(
+        "Bash",
+        Some(&serde_json::json!({ "command": shown }).to_string()),
+    );
+    if !reopen_policy(home)
+        .0
+        .allows_offload(&class, counter.count(&stdout) as u64)
+    {
+        optimizer.set_offload_mode(secondwind_optimize::OffloadMode::Off);
+    }
     let (effective, note, transform, saved_usd, inline) = match optimizer.compress_block(&stdout) {
         Outcome::Compressed {
             wire,
diff --git a/crates/cli/src/mcp.rs b/crates/cli/src/mcp.rs
index 4db6841..46fb49d 100644
--- a/crates/cli/src/mcp.rs
+++ b/crates/cli/src/mcp.rs
@@ -22,6 +22,7 @@ pub fn serve(home: &Path) -> ExitCode {
             crate::proxy::store_dir(home),
             crate::proxy::OFFLOAD_TTL,
         ));
+    let (policy, _) = crate::reopen_policy(home);
     let stdin = std::io::stdin();
     let mut stdout = std::io::stdout();
 
@@ -50,6 +51,7 @@ pub fn serve(home: &Path) -> ExitCode {
                 id,
                 &request,
                 &mut optimizer,
+                &policy,
                 counter.as_ref(),
                 home,
             )),
@@ -74,7 +76,9 @@ fn tool_defs() -> Vec<Value> {
                 "type": "object",
                 "properties": {
                     "block": { "type": "string", "description": "The tool output to compress." },
-                    "query": { "type": "string", "description": "Optional request text; relevant rows are kept inline." }
+                    "query": { "type": "string", "description": "Optional request text; for a JSON array of records, the rows most relevant to it are kept inline." },
+                    "tool": { "type": "string", "description": "Optional: the tool that produced the block (Bash, Read, Grep, ...). With it, output that is usually needed whole stays in view instead of being offloaded." },
+                    "command": { "type": "string", "description": "Optional: for Bash, the command that produced the block." }
                 },
                 "required": ["block"]
             }
@@ -104,6 +108,7 @@ fn handle_call(
     id: Option<Value>,
     request: &Value,
     optimizer: &mut Optimizer,
+    policy: &secondwind_optimize::policy::ReopenPolicy,
     counter: &Tiktoken,
     home: &std::path::Path,
 ) -> Value {
@@ -114,12 +119,24 @@ fn handle_call(
     match name {
         "optimize" => {
             let block = args["block"].as_str().unwrap_or("");
+            let mode = optimizer.offload_mode();
+            if let Some(tool) = args["tool"].as_str() {
+                let input = args["command"]
+                    .as_str()
+                    .map(|command| json!({ "command": command }).to_string());
+                let class =
+                    secondwind_optimize::counterfactual::command_class(tool, input.as_deref());
+                if !policy.allows_offload(&class, counter.count(block) as u64) {
+                    optimizer.set_offload_mode(secondwind_optimize::OffloadMode::Off);
+                }
+            }
             let outcome = match args["query"].as_str() {
                 Some(query) if !query.is_empty() => {
                     optimizer.compress_block_with_query(block, query)
                 }
                 _ => optimizer.compress_block(block),
             };
+            optimizer.set_offload_mode(mode);
             let (text, transform, saved_usd, inline) = match outcome {
                 Outcome::Compressed {
                     wire,
diff --git a/crates/cli/tests/gate.rs b/crates/cli/tests/gate.rs
new file mode 100644
index 0000000..1a01eae
--- /dev/null
+++ b/crates/cli/tests/gate.rs
@@ -0,0 +1,141 @@
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+use serde_json::{Value, json};
+
+fn home(tag: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("sw-gate-{}-{tag}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+// A body the optimizer offloads as a code outline when nothing stops it.
+fn code() -> String {
+    (0..200)
+        .map(|i| {
+            format!(
+                "fn handler_{i}(input: &str) -> Result<usize> {{ let key = uniquetoken{i} ; parse(input).map(|v| v * {i}) }}\n"
+            )
+        })
+        .collect()
+}
+
+fn optimize(home: &Path, arguments: Value) -> String {
+    let call = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call",
+                       "params": { "name": "optimize", "arguments": arguments } });
+    let mut server = Command::new(env!("CARGO_BIN_EXE_secondwind"))
+        .arg("--home")
+        .arg(home)
+        .arg("mcp")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()
+        .unwrap();
+    server
+        .stdin
+        .take()
+        .unwrap()
+        .write_all(format!("{call}\n").as_bytes())
+        .unwrap();
+    let out = server.wait_with_output().unwrap();
+    let response: Value = serde_json::from_slice(&out.stdout).unwrap();
+    response["result"]["content"][0]["text"]
+        .as_str()
+        .unwrap()
+        .to_string()
+}
+
+#[test]
+fn a_large_cat_stays_in_view_while_the_same_block_unnamed_is_offloaded() {
+    let home = home("mcp");
+    let unnamed = optimize(&home, json!({ "block": code() }));
+    assert!(
+        unnamed.contains("<<swload:"),
+        "offloaded: {}",
+        &unnamed[..80]
+    );
+
+    let cat = optimize(
+        &home,
+        json!({ "block": code(), "tool": "Bash", "command": "cat src/handlers.rs" }),
+    );
+    assert!(!cat.contains("<<swload:"), "a whole read is not hidden");
+    assert!(cat.contains("uniquetoken137"), "every line stays in view");
+}
+
+#[test]
+fn exec_keeps_a_large_cat_in_view() {
+    let home = home("exec");
+    let file = home.join("handlers.rs");
+    std::fs::write(&file, code()).unwrap();
+    let out = Command::new(env!("CARGO_BIN_EXE_secondwind"))
+        .arg("--home")
+        .arg(&home)
+        .args(["exec", "--", "cat"])
+        .arg(&file)
+        .output()
+        .unwrap();
+    assert!(out.status.success());
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(!stdout.contains("<<swload:"));
+    assert!(stdout.contains("uniquetoken137"));
+}
+
+#[test]
+fn a_learned_policy_replaces_the_built_in_one() {
+    let home = home("learned");
+    let policy = json!({ "version": 1, "threshold": 0.4, "prior": 0.05, "classes": {
+        "Bash:cat": { "rate": 0.05, "n": 1000, "sizes": {} } } });
+    std::fs::create_dir_all(home.join(".secondwind")).unwrap();
+    std::fs::write(home.join(".secondwind/policy.json"), policy.to_string()).unwrap();
+
+    let cat = optimize(
+        &home,
+        json!({ "block": code(), "tool": "Bash", "command": "cat src/handlers.rs" }),
+    );
+    assert!(
+        cat.contains("<<swload:"),
+        "this user's cats are rarely reopened"
+    );
+}
+
+#[test]
+fn eval_learn_writes_a_policy_and_reports_held_out_sessions() {
+    let home = home("learn");
+    let projects = home.join(".claude/projects/demo");
+    std::fs::create_dir_all(&projects).unwrap();
+    for n in 0..4 {
+        let session = [
+            json!({ "type": "assistant", "sessionId": format!("s-{n}"), "timestamp": "2026-10-23T10:00:00Z",
+                    "isSidechain": false, "message": { "role": "assistant", "content": [
+                        { "type": "tool_use", "id": "t1", "name": "Bash", "input": { "command": "cat a.rs" } } ] } }),
+            json!({ "type": "user", "sessionId": format!("s-{n}"), "timestamp": "2026-10-23T10:00:01Z",
+                    "isSidechain": false, "message": { "role": "user", "content": [
+                        { "type": "tool_result", "tool_use_id": "t1", "content": code() } ] } }),
+            json!({ "type": "assistant", "sessionId": format!("s-{n}"), "timestamp": "2026-10-23T10:00:02Z",
+                    "isSidechain": false, "message": { "role": "assistant", "content": [
+                        { "type": "text", "text": "uniquetoken137 is the key" } ] } }),
+        ];
+        let lines: Vec<String> = session.iter().map(Value::to_string).collect();
+        std::fs::write(projects.join(format!("s-{n}.jsonl")), lines.join("\n")).unwrap();
+    }
+
+    let out = Command::new(env!("CARGO_BIN_EXE_secondwind"))
+        .arg("--home")
+        .arg(&home)
+        .args(["eval", "--learn"])
+        .output()
+        .unwrap();
+    assert!(
+        out.status.success(),
+        "{}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let report: Value = serde_json::from_slice(&out.stdout).unwrap();
+    let held = &report["held_out"];
+    assert_eq!(held["without_gate"]["reopened"], 2);
+    assert_eq!(held["with_gate"]["unfaithful"], 0);
+    assert!(home.join(".secondwind/policy.json").exists());
+}
diff --git a/crates/optimize/src/counterfactual.rs b/crates/optimize/src/counterfactual.rs
index 6e92e8b..3265d0e 100644
--- a/crates/optimize/src/counterfactual.rs
+++ b/crates/optimize/src/counterfactual.rs
@@ -150,13 +150,15 @@ pub struct BlockOutcome {
 }
 
 // Runs the optimizer over every tool result in a trace. Takes a fresh optimizer per trace so the
-// offload store never outlives it. A hidden token counts as needed only when the assistant uses it
+// offload store never outlives it. With a gate, a block whose predicted reopen rate is at or over its
+// threshold is compressed with offloading off, so only inline codecs apply. A hidden token counts as needed only when the assistant uses it
 // before any later tool result or user message supplies it again, so a grep followed by a read of
 // the same file charges the read, not the grep.
 pub fn evaluate(
     trace: &Trace,
     optimizer: &mut crate::Optimizer,
     counter: &dyn crate::tokens::TokenCounter,
+    gate: Option<&crate::policy::ReopenPolicy>,
 ) -> Vec<BlockOutcome> {
     let first_seen = first_seen_index(trace);
     let assistant_tokens = assistant_token_index(trace);
@@ -212,6 +214,11 @@ pub fn evaluate(
             }
             let input = id.as_deref().and_then(|id| calls.get(id)).map(|c| c.1);
             let raw_tokens = counter.count(body) as u64;
+            let class = command_class(tool, input);
+            let mode = optimizer.offload_mode();
+            if gate.is_some_and(|g| !g.allows_offload(&class, raw_tokens)) {
+                optimizer.set_offload_mode(crate::OffloadMode::Off);
+            }
             // Faithful is checked here independently of the optimizer's own gate: an inline wire
             // must decode to the certified content, an offload must resolve to the original.
             let (outcome, sent, hidden_from, faithful) = match optimizer.compress_block(body) {
@@ -227,6 +234,7 @@ pub fn evaluate(
                 }
                 crate::Outcome::KeptVerbatim { .. } => ("verbatim", body.to_string(), None, true),
             };
+            optimizer.set_offload_mode(mode);
             let reopened = hidden_from.is_some_and(|stub| {
                 residual_tokens(body, &stub)
                     .iter()
@@ -234,7 +242,7 @@ pub fn evaluate(
             });
             out.push(BlockOutcome {
                 tool: tool.clone(),
-                class: command_class(tool, input),
+                class,
                 shape: classify(body),
                 outcome,
                 turn: ti,
@@ -483,7 +491,12 @@ mod tests {
 
     fn evaluated(turns: Vec<Turn>) -> Vec<BlockOutcome> {
         let mut optimizer = crate::Optimizer::default();
-        evaluate(&trace(turns), &mut optimizer, &crate::tokens::ByteCounter)
+        evaluate(
+            &trace(turns),
+            &mut optimizer,
+            &crate::tokens::ByteCounter,
+            None,
+        )
     }
 
     #[test]
@@ -510,6 +523,26 @@ mod tests {
         assert!(!out[0].reopened, "the model read it from the second result");
     }
 
+    #[test]
+    fn a_gate_keeps_a_block_it_expects_reopened_in_view() {
+        let mut policy = crate::policy::ReopenPolicy::learn(std::iter::empty(), 1);
+        policy.prior = 0.9;
+        let mut optimizer = crate::Optimizer::default();
+        let out = evaluate(
+            &trace(vec![
+                tool_turn(0, &code_body()),
+                assistant_turn(1, "I will use uniquetoken137 from the results"),
+            ]),
+            &mut optimizer,
+            &crate::tokens::ByteCounter,
+            Some(&policy),
+        );
+        assert_ne!(out[0].outcome, "offload");
+        assert!(!out[0].reopened, "nothing was hidden, so nothing to reopen");
+        assert!(out[0].faithful);
+        assert_eq!(optimizer.offload_mode(), crate::OffloadMode::Auto);
+    }
+
     #[test]
     fn every_shape_the_optimizer_touches_is_faithful() {
         let json = format!(
diff --git a/crates/optimize/src/lib.rs b/crates/optimize/src/lib.rs
index ada9335..cb0291c 100644
--- a/crates/optimize/src/lib.rs
+++ b/crates/optimize/src/lib.rs
@@ -27,6 +27,7 @@ pub mod netcost;
 pub mod norm;
 pub mod offload;
 pub mod outline;
+pub mod policy;
 pub mod prefix;
 pub mod prose;
 pub mod proxy;
diff --git a/crates/optimize/src/policy.rs b/crates/optimize/src/policy.rs
new file mode 100644
index 0000000..554058b
--- /dev/null
+++ b/crates/optimize/src/policy.rs
@@ -0,0 +1,200 @@
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::counterfactual::BlockOutcome;
+
+// Measured reopen rates per command class and size, and the line above which offloading a block
+// costs more extra turns than it saves. A class or size with too few offloads falls back to the
+// class, then to the prior. The built-in table comes from 1,491 real Claude Code sessions;
+// `secondwind eval --learn` fits one to the user's own history.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ReopenPolicy {
+    pub version: u32,
+    pub threshold: f64,
+    pub prior: f64,
+    pub classes: BTreeMap<String, ClassRate>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct ClassRate {
+    pub rate: f64,
+    pub n: u64,
+    #[serde(default)]
+    pub sizes: BTreeMap<String, Rate>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+pub struct Rate {
+    pub rate: f64,
+    pub n: u64,
+}
+
+pub const DEFAULT_THRESHOLD: f64 = 0.4;
+// Reopens and offloads.
+type Counts = [u64; 2];
+const BUILTIN: &str = include_str!("reopen_rates.json");
+
+impl ReopenPolicy {
+    pub fn builtin() -> Self {
+        serde_json::from_str(BUILTIN).expect("the built-in reopen table parses")
+    }
+
+    pub fn from_json(text: &str) -> Option<Self> {
+        serde_json::from_str::<Self>(text)
+            .ok()
+            .filter(|p| p.version == 1 && (0.0..=1.0).contains(&p.threshold))
+    }
+
+    // Laplace-smoothed rates from offloaded blocks; a class or size needs `min` offloads to count.
+    pub fn learn<'a>(blocks: impl IntoIterator<Item = &'a BlockOutcome>, min: u64) -> Self {
+        let mut all: Counts = [0; 2];
+        let mut classes: BTreeMap<String, (Counts, BTreeMap<&'static str, Counts>)> =
+            BTreeMap::new();
+        for b in blocks.into_iter().filter(|b| b.outcome == "offload") {
+            let hit = u64::from(b.reopened);
+            let entry = classes.entry(b.class.clone()).or_default();
+            for counts in [
+                &mut all,
+                &mut entry.0,
+                entry.1.entry(size_band(b.raw_tokens)).or_default(),
+            ] {
+                counts[0] += hit;
+                counts[1] += 1;
+            }
+        }
+        let smooth = |c: Counts| Rate {
+            rate: (c[0] + 1) as f64 / (c[1] + 2) as f64,
+            n: c[1],
+        };
+        Self {
+            version: 1,
+            threshold: DEFAULT_THRESHOLD,
+            prior: smooth(all).rate,
+            classes: classes
+                .into_iter()
+                .filter(|(_, (counts, _))| counts[1] >= min)
+                .map(|(class, (counts, sizes))| {
+                    let whole = smooth(counts);
+                    let sizes = sizes
+                        .into_iter()
+                        .filter(|(_, c)| c[1] >= min)
+                        .map(|(band, c)| (band.to_string(), smooth(c)))
+                        .collect();
+                    (
+                        class,
+                        ClassRate {
+                            rate: whole.rate,
+                            n: whole.n,
+                            sizes,
+                        },
+                    )
+                })
+                .collect(),
+        }
+    }
+
+    pub fn predicted(&self, class: &str, raw_tokens: u64) -> f64 {
+        let Some(c) = self.classes.get(class) else {
+            return self.prior;
+        };
+        c.sizes
+            .get(size_band(raw_tokens))
+            .map_or(c.rate, |size| size.rate)
+    }
+
+    pub fn allows_offload(&self, class: &str, raw_tokens: u64) -> bool {
+        self.predicted(class, raw_tokens) < self.threshold
+    }
+}
+
+pub fn size_band(raw_tokens: u64) -> &'static str {
+    match raw_tokens {
+        0..500 => "<500",
+        500..2000 => "<2k",
+        2000..8000 => "<8k",
+        _ => "8k+",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn block(class: &str, raw_tokens: u64, reopened: bool) -> BlockOutcome {
+        BlockOutcome {
+            tool: "Bash".into(),
+            class: class.into(),
+            shape: "other".into(),
+            outcome: "offload",
+            turn: 0,
+            raw_bytes: raw_tokens as usize * 4,
+            raw_tokens,
+            sent_tokens: 10,
+            reopened,
+            faithful: true,
+            context_tokens: 0,
+            turns_after: 0,
+        }
+    }
+
+    #[test]
+    fn the_builtin_table_parses_and_ranks_whole_reads_above_searches() {
+        let p = ReopenPolicy::builtin();
+        assert_eq!(p.threshold, DEFAULT_THRESHOLD);
+        assert!(p.predicted("Read", 5000) > p.predicted("Bash:grep |", 300));
+        assert!(
+            !p.allows_offload("Bash:cat", 5000),
+            "a large cat is read whole"
+        );
+        assert!(p.allows_offload("Bash:grep |", 300), "a small grep is not");
+    }
+
+    #[test]
+    fn prediction_falls_back_from_size_to_class_to_prior() {
+        let mut blocks: Vec<BlockOutcome> = (0..40)
+            .map(|i| block("Bash:cat", 3000, i % 4 != 0))
+            .collect();
+        blocks.extend((0..40).map(|_| block("Bash:cat", 100, false)));
+        blocks.extend((0..5).map(|_| block("Bash:rare", 100, true)));
+        let p = ReopenPolicy::learn(&blocks, 30);
+
+        assert!(p.predicted("Bash:cat", 3000) > 0.7);
+        assert!(p.predicted("Bash:cat", 100) < 0.05);
+        let class_rate = p.classes["Bash:cat"].rate;
+        assert_eq!(
+            p.predicted("Bash:cat", 20_000),
+            class_rate,
+            "no 8k+ band, so the class"
+        );
+        assert_eq!(
+            p.predicted("Bash:rare", 100),
+            p.prior,
+            "too few offloads, so the prior"
+        );
+    }
+
+    #[test]
+    fn learn_ignores_blocks_that_were_not_offloaded() {
+        let mut inline = block("Bash:cat", 3000, false);
+        inline.outcome = "inline";
+        let p = ReopenPolicy::learn(&[inline], 1);
+        assert!(p.classes.is_empty());
+    }
+
+    #[test]
+    fn a_policy_round_trips_and_a_bad_one_is_refused() {
+        let p = ReopenPolicy::builtin();
+        let text = serde_json::to_string(&p).unwrap();
+        assert_eq!(ReopenPolicy::from_json(&text), Some(p));
+        assert_eq!(
+            ReopenPolicy::from_json(r#"{"version":2,"threshold":0.4,"prior":0.4,"classes":{}}"#),
+            None
+        );
+        assert_eq!(
+            ReopenPolicy::from_json(r#"{"version":1,"threshold":7,"prior":0.4,"classes":{}}"#),
+            None
+        );
+        assert_eq!(ReopenPolicy::from_json("not json"), None);
+    }
+}
diff --git a/crates/optimize/src/reopen_rates.json b/crates/optimize/src/reopen_rates.json
new file mode 100644
index 0000000..bbbc004
--- /dev/null
+++ b/crates/optimize/src/reopen_rates.json
@@ -0,0 +1,291 @@
+{
+ "version": 1,
+ "threshold": 0.4,
+ "prior": 0.44,
+ "classes": {
+  "WebFetch": {
+   "rate": 0.63,
+   "n": 11378,
+   "sizes": {
+    "<500": {
+     "rate": 0.57,
+     "n": 8745
+    },
+    "<2k": {
+     "rate": 0.83,
+     "n": 2446
+    }
+   }
+  },
+  "Bash:grep |": {
+   "rate": 0.3,
+   "n": 9708,
+   "sizes": {
+    "<500": {
+     "rate": 0.15,
+     "n": 4303
+    },
+    "<2k": {
+     "rate": 0.38,
+     "n": 4598
+    },
+    "<8k": {
+     "rate": 0.66,
+     "n": 789
+    }
+   }
+  },
+  "Bash:sed": {
+   "rate": 0.5,
+   "n": 6947,
+   "sizes": {
+    "<500": {
+     "rate": 0.15,
+     "n": 1415
+    },
+    "<2k": {
+     "rate": 0.48,
+     "n": 3472
+    },
+    "<8k": {
+     "rate": 0.78,
+     "n": 2044
+    }
+   }
+  },
+  "WebSearch": {
+   "rate": 0.64,
+   "n": 6820,
+   "sizes": {
+    "<2k": {
+     "rate": 0.64,
+     "n": 6712
+    }
+   }
+  },
+  "Bash:loop": {
+   "rate": 0.31,
+   "n": 4739,
+   "sizes": {
+    "<500": {
+     "rate": 0.16,
+     "n": 2177
+    },
+    "<2k": {
+     "rate": 0.36,
+     "n": 1899
+    },
+    "<8k": {
+     "rate": 0.69,
+     "n": 643
+    }
+   }
+  },
+  "Bash:other": {
+   "rate": 0.39,
+   "n": 4662,
+   "sizes": {
+    "<500": {
+     "rate": 0.24,
+     "n": 1897
+    },
+    "<2k": {
+     "rate": 0.41,
+     "n": 1985
+    },
+    "<8k": {
+     "rate": 0.69,
+     "n": 767
+    }
+   }
+  },
+  "Bash:python3 -": {
+   "rate": 0.25,
+   "n": 3903,
+   "sizes": {
+    "<500": {
+     "rate": 0.12,
+     "n": 1610
+    },
+    "<2k": {
+     "rate": 0.29,
+     "n": 1746
+    },
+    "<8k": {
+     "rate": 0.46,
+     "n": 531
+    }
+   }
+  },
+  "Read": {
+   "rate": 0.73,
+   "n": 3407,
+   "sizes": {
+    "<2k": {
+     "rate": 0.65,
+     "n": 992
+    },
+    "<8k": {
+     "rate": 0.79,
+     "n": 1359
+    },
+    "8k+": {
+     "rate": 0.88,
+     "n": 826
+    }
+   }
+  },
+  "Bash:cat": {
+   "rate": 0.69,
+   "n": 3246,
+   "sizes": {
+    "<500": {
+     "rate": 0.26,
+     "n": 316
+    },
+    "<2k": {
+     "rate": 0.52,
+     "n": 1062
+    },
+    "<8k": {
+     "rate": 0.87,
+     "n": 1817
+    }
+   }
+  },
+  "Bash:sed |": {
+   "rate": 0.3,
+   "n": 1925,
+   "sizes": {
+    "<500": {
+     "rate": 0.11,
+     "n": 662
+    },
+    "<2k": {
+     "rate": 0.33,
+     "n": 935
+    },
+    "<8k": {
+     "rate": 0.61,
+     "n": 319
+    }
+   }
+  },
+  "Bash:ls": {
+   "rate": 0.48,
+   "n": 1274,
+   "sizes": {
+    "<500": {
+     "rate": 0.27,
+     "n": 457
+    },
+    "<2k": {
+     "rate": 0.53,
+     "n": 587
+    }
+   }
+  },
+  "Agent": {
+   "rate": 0.02,
+   "n": 1187,
+   "sizes": {
+    "<500": {
+     "rate": 0.02,
+     "n": 1187
+    }
+   }
+  },
+  "Bash:cat |": {
+   "rate": 0.52,
+   "n": 1124,
+   "sizes": {
+    "<2k": {
+     "rate": 0.47,
+     "n": 464
+    },
+    "<8k": {
+     "rate": 0.74,
+     "n": 406
+    }
+   }
+  },
+  "Bash:grep": {
+   "rate": 0.24,
+   "n": 1109,
+   "sizes": {
+    "<500": {
+     "rate": 0.14,
+     "n": 597
+    },
+    "<2k": {
+     "rate": 0.34,
+     "n": 464
+    }
+   }
+  },
+  "Bash:ls |": {
+   "rate": 0.42,
+   "n": 1052,
+   "sizes": {
+    "<500": {
+     "rate": 0.29,
+     "n": 464
+    },
+    "<2k": {
+     "rate": 0.49,
+     "n": 493
+    }
+   }
+  },
+  "Bash:curl |": {
+   "rate": 0.43,
+   "n": 803,
+   "sizes": {
+    "<2k": {
+     "rate": 0.48,
+     "n": 466
+    }
+   }
+  },
+  "Bash:node |": {
+   "rate": 0.18,
+   "n": 783,
+   "sizes": {
+    "<500": {
+     "rate": 0.1,
+     "n": 471
+    }
+   }
+  },
+  "Bash:head": {
+   "rate": 0.57,
+   "n": 635,
+   "sizes": {}
+  },
+  "Bash:node": {
+   "rate": 0.37,
+   "n": 627,
+   "sizes": {
+    "<500": {
+     "rate": 0.15,
+     "n": 323
+    }
+   }
+  },
+  "Bash:wc": {
+   "rate": 0.5,
+   "n": 459,
+   "sizes": {}
+  },
+  "Bash:tail": {
+   "rate": 0.25,
+   "n": 452,
+   "sizes": {}
+  },
+  "Bash:gh api": {
+   "rate": 0.48,
+   "n": 330,
+   "sizes": {}
+  }
+ }
+}
diff --git a/docs/CLAUDE_CODE.md b/docs/CLAUDE_CODE.md
index cec7945..988321b 100644
--- a/docs/CLAUDE_CODE.md
+++ b/docs/CLAUDE_CODE.md
@@ -40,7 +40,8 @@ block has been compressed.
 
 ## What happens to a result
 
-1. A Bash result of 6 KB or more is sent to `secondwind mcp`'s `optimize` tool. Smaller results,
+1. A Bash result of 512 bytes or more is sent to `secondwind mcp`'s `optimize` tool with the
+   command that produced it. Smaller results,
    errors and `stderr` pass through. Claude Code caps a Bash result at 30,000 characters before any
    plugin sees it, so the mod compresses what remains.
 2. The model reads the stub the optimizer returns: a shape-aware preview (a diff summary, a match
@@ -72,7 +73,7 @@ Compressed blocks carry exact token counts read from the binary's ledger. Everyt
 
 ## Limits
 
-- Bash results only, 6 KB and up, after Claude Code's own 30,000-character cap.
+- Bash results only, 512 bytes and up, after Claude Code's own 30,000-character cap.
 - Figures are per session and live in the session's state; `secondwind watch` and the web
   dashboard read the binary's lifetime ledger instead.
 - The pane draws on the terminal and desktop surfaces; the bars are images on the desktop and
diff --git a/integrations/claude-code/README.md b/integrations/claude-code/README.md
index 7886cb3..5a2d9b9 100644
--- a/integrations/claude-code/README.md
+++ b/integrations/claude-code/README.md
@@ -39,7 +39,9 @@ What the pane shows:
 Net is raw minus sent minus handed back, so a block the model resolves in full shows as a cost,
 in red. `≈` marks a byte estimate; exact figures come from the binary's ledger.
 
-Only Bash results of 6 KB or more are compressed. Claude Code caps a Bash result at 30,000
+Bash results of 512 bytes or more go to the binary, with the command that produced them. The
+binary keeps output that is usually read whole in view, such as a large `cat`, and offloads the
+rest; `secondwind eval --learn` fits that choice to your own sessions. Claude Code caps a Bash result at 30,000
 characters before any plugin sees it, so the mod compresses what remains.
 
 ## Develop
diff --git a/integrations/claude-code/hooks/register.tsx b/integrations/claude-code/hooks/register.tsx
index 893c86e..e54b52d 100644
--- a/integrations/claude-code/hooks/register.tsx
+++ b/integrations/claude-code/hooks/register.tsx
@@ -4,7 +4,7 @@ import type { Color, EngineInterface, Register } from 'claude-code'
 import type { Marker, Stats } from '../types'
 
 const PANE = 'secondwind'
-const MIN_BYTES = 6000
+const MIN_BYTES = 512
 const MARKER = /<<swload:[0-9a-f]{16}>>/
 const RECENT = 8
 const ACCENT: Color = 'claude'
@@ -202,7 +202,7 @@ export const register: Register = on => {
     const since = Date.now()
     let answer: Answer
     try {
-      answer = await rpc($, 'optimize', { block: stdout })
+      answer = await rpc($, 'optimize', { block: stdout, tool: 'Bash', command: e.command })
     } catch {
       await update($, stats, s => ({ ...EMPTY, ...s, failed: s.failed + 1, seenTokens: s.seenTokens + estimate(stdout) }))
       return ran
@@ -402,7 +402,7 @@ export const register: Register = on => {
         )}
 
         <Box marginTop={1}>
-          <Text dimColor>{list.length ? `recent` : isOn ? 'Bash output over 6 KB lands here.' : 'Turn on to compress Bash output in this session.'}</Text>
+          <Text dimColor>{list.length ? `recent` : isOn ? 'Bash output over 512 bytes lands here.' : 'Turn on to compress Bash output in this session.'}</Text>
         </Box>
         {recent.map(m => (
           <Box key={m.marker} flexDirection="row" gap={1}>
diff --git a/integrations/claude-code/tests/secondwind.test.tsx b/integrations/claude-code/tests/secondwind.test.tsx
index 7d6ae41..a0ec58d 100644
--- a/integrations/claude-code/tests/secondwind.test.tsx
+++ b/integrations/claude-code/tests/secondwind.test.tsx
@@ -25,7 +25,10 @@ function answer(text: string, isError = false): string {
   })}\n`
 }
 
-function engine(on: Parameters<Parameters<typeof test>[1]>[1], stdout = '') {
+type Sent = { name: string; arguments: Record<string, unknown> }
+
+function engine(on: Parameters<Parameters<typeof test>[1]>[1], stdout = '', bash = BIG): Sent[] {
+  const sent: Sent[] = []
   on('tool.register', () => ({ value: { tool: 'mcp__secondwind__recover' } }))
   on('command.register', () => ({ value: { command: 'secondwind' } }))
   on('ui.open', () => ({ value: { isPlaced: true } }))
@@ -38,12 +41,14 @@ function engine(on: Parameters<Parameters<typeof test>[1]>[1], stdout = '') {
     if (argv.startsWith('tail')) return { value: { exitCode: 1, stdout: '', stderr: '' } }
     const call = JSON.parse(e.init?.stdin ?? '{}')
     const name = call.params?.name
+    sent.push(call.params)
     const text = name === 'optimize' ? stdout : name === 'resolve' ? BIG : 'unknown'
     return { value: { exitCode: 0, stdout: answer(text, name === 'unknown'), stderr: '' } }
   })
   on('tool.call', { tool: 'Bash' }, () => ({
-    result: { stdout: BIG, stderr: '', interrupted: false },
+    result: { stdout: bash, stderr: '', interrupted: false },
   }))
+  return sent
 }
 
 test('large Bash output is replaced by the stub and the pane books it net', async ($, on) => {
@@ -68,6 +73,29 @@ test('large Bash output is replaced by the stub and the pane books it net', asyn
   }
 })
 
+test('the binary hears which command produced the output, so it can keep a whole read in view', async ($, on) => {
+  const sent = engine(on, STUB)
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  await $.command.run({ command: 'secondwind', args: 'on' })
+
+  await $.tool.call({ tool: 'Bash', command: 'cat big.txt' })
+  const optimize = sent.find(call => call.name === 'optimize')
+  expect(optimize?.arguments.tool).toBe('Bash')
+  expect(optimize?.arguments.command).toBe('cat big.txt')
+  expect(optimize?.arguments.block).toBe(BIG)
+})
+
+test('output under 512 bytes never reaches the binary', async ($, on) => {
+  const small = 'x'.repeat(511)
+  const sent = engine(on, STUB, small)
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  await $.command.run({ command: 'secondwind', args: 'on' })
+
+  const ran = await $.tool.call({ tool: 'Bash', command: 'ls' })
+  expect((ran.result as { stdout: string }).stdout).toBe(small)
+  expect(sent.filter(call => call.name === 'optimize')).toHaveLength(0)
+})
+
 test('small output and a verbatim answer pass through untouched', async ($, on) => {
   engine(on, BIG)
   await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
@@ -97,3 +125,56 @@ test('compression is off by default and the pane button turns it on for the sess
   const off2 = await $.tool.call({ tool: 'Bash', command: 'cat big.txt' })
   expect((off2.result as { stdout: string }).stdout).toBe(BIG)
 })
+
+const SURFACES = ['terminal', 'desktop'] as const
+
+async function percentTile($: Parameters<Parameters<typeof test>[1]>[0], surface: (typeof SURFACES)[number]) {
+  const ui = await $.ui.mount({ ...PANE, surface })
+  const value = await ui.find({ type: 'Text', text: /%$/ })
+  const toggle = await ui.find({ key: 'toggle' })
+  const hint = await ui.find({ type: 'Text', text: /lands here|Turn on to compress/ })
+  await ui.unmount()
+  return { value, toggle, hint }
+}
+
+test('off: the pane offers to turn on and says what it would do', async ($, on) => {
+  engine(on, STUB)
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  for (const surface of SURFACES) {
+    const { toggle, hint, value } = await percentTile($, surface)
+    expect(toggle?.text).toContain('turn on')
+    expect(hint?.text).toBe('Turn on to compress Bash output in this session.')
+    expect(value?.props.color).toBeUndefined()
+  }
+})
+
+test('on and empty: the pane says where output will land', async ($, on) => {
+  engine(on, STUB)
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  await $.command.run({ command: 'secondwind', args: 'on' })
+  for (const surface of SURFACES) {
+    const { toggle, hint, value } = await percentTile($, surface)
+    expect(toggle?.text).toContain('turn off')
+    expect(hint?.text).toBe('Bash output over 512 bytes lands here.')
+    expect(value?.text).toBe('0%')
+  }
+})
+
+test('a win draws the net in the accent, a loss in red', async ($, on) => {
+  engine(on, STUB)
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  await $.command.run({ command: 'secondwind', args: 'on' })
+  await $.tool.call({ tool: 'Bash', command: 'cat big.txt' })
+  for (const surface of SURFACES) {
+    const { value } = await percentTile($, surface)
+    expect(value?.text).not.toContain('-')
+    expect(value?.props.color).toBe('claude')
+  }
+
+  await $.tool.call({ tool: 'mcp__secondwind__recover', marker: '<<swload:0123456789abcdef>>' })
+  for (const surface of SURFACES) {
+    const { value } = await percentTile($, surface)
+    expect(value?.text).toContain('-')
+    expect(value?.props.color).toBe('error')
+  }
+})