From dd0ec612a3023336e3ececfc73c3bfe9355fc7c3 Mon Sep 17 00:00:00 2001
From: hardy30894 <harshdubeyjp@gmail.com>
Date: Thu, 22 Oct 2026 22:07:29 -0400
Subject: [PATCH 1/2] fix: read a tool result as the model saw it

The Claude Code reader wrote a tool result's content array out as raw JSON, so text results carried a wrapper the model never sees and images and PDFs carried their base64 as text. On real sessions that made tool output look seven times larger than it is, inflating cache-savings and the audit. Text blocks are now joined and an image or document is a short placeholder.
---
 crates/sources/src/claude_code.rs | 41 ++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)

diff --git a/crates/sources/src/claude_code.rs b/crates/sources/src/claude_code.rs
index de57bb5..56bb4c9 100644
--- a/crates/sources/src/claude_code.rs
+++ b/crates/sources/src/claude_code.rs
@@ -218,7 +218,7 @@ fn segments_from(content: Content, tool_names: &mut HashMap<String, String>) ->
                         id: tool_use_id,
                     },
                     original: None,
-                    effective: value_to_text(content),
+                    effective: tool_result_text(content),
                 });
             }
             Block::Unknown => {}
@@ -227,6 +227,23 @@ fn segments_from(content: Content, tool_names: &mut HashMap<String, String>) ->
     segments
 }
 
+// A tool result as the model read it: text blocks joined, an image or document named by a short
+// placeholder rather than its base64 payload, which no text codec could compress anyway.
+fn tool_result_text(content: serde_json::Value) -> String {
+    let serde_json::Value::Array(blocks) = content else {
+        return value_to_text(content);
+    };
+    blocks
+        .into_iter()
+        .map(|block| match block["type"].as_str() {
+            Some("text") => block["text"].as_str().unwrap_or_default().to_string(),
+            Some(kind @ ("image" | "document")) => format!("[{kind}]"),
+            _ => block.to_string(),
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
 fn value_to_text(value: serde_json::Value) -> String {
     match value {
         serde_json::Value::String(s) => s,
@@ -338,3 +355,25 @@ impl From<Usage> for Billing {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn a_tool_result_reads_as_the_model_saw_it() {
+        let content = json!([
+            { "type": "text", "text": "line one" },
+            { "type": "image", "source": { "type": "base64", "data": "iVBORw0KGgoAAAANSUhEUg" } },
+            { "type": "text", "text": "line two" }
+        ]);
+        assert_eq!(tool_result_text(content), "line one\n[image]\nline two");
+    }
+
+    #[test]
+    fn a_plain_string_result_is_unchanged() {
+        assert_eq!(tool_result_text(json!("ok\n")), "ok\n");
+        assert_eq!(tool_result_text(serde_json::Value::Null), "");
+    }
+}

From beb26446751029402ce606c623c18abeaba6f5c1 Mon Sep 17 00:00:00 2001
From: hardy30894 <harshdubeyjp@gmail.com>
Date: Thu, 22 Oct 2026 22:07:29 -0400
Subject: [PATCH 2/2] feat: secondwind eval replays recorded sessions through
 the optimizer

Per tool and command: blocks kept inline or offloaded, how often the model later needed what an offload hid, and net tokens. A hidden token counts only if the model used it before another result supplied it again. Every block is checked faithful independently of the optimizer's gate, and --blocks writes one line per result with its context size and remaining turns for policy studies.
---
 README.md                             |   1 +
 crates/cli/src/main.rs                | 138 ++++++++++
 crates/cli/tests/eval.rs              | 105 +++++++
 crates/optimize/src/counterfactual.rs | 380 ++++++++++++++++++++++++++
 4 files changed, 624 insertions(+)
 create mode 100644 crates/cli/tests/eval.rs

diff --git a/README.md b/README.md
index ce89394..933bbf1 100644
--- a/README.md
+++ b/README.md
@@ -348,6 +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 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 772dae9..b30eac3 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -97,6 +97,19 @@ enum Command {
         #[arg(long, default_value_t = 0)]
         limit: usize,
     },
+    #[command(
+        about = "Replay discovered traces through the optimizer: tokens sent, reopens and net savings per tool and command"
+    )]
+    Eval {
+        #[arg(long, default_value_t = 0, help = "Read at most this many trace files")]
+        limit: usize,
+        #[arg(
+            long,
+            value_name = "PATH",
+            help = "Also write one JSON line per tool result"
+        )]
+        blocks: Option<PathBuf>,
+    },
     #[command(
         about = "Estimate the tokens the optimizer would remove across your discovered traffic"
     )]
@@ -296,6 +309,7 @@ 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::CacheSavings { limit }) => return cache_savings(&home, limit),
         Some(Command::Exec { script, command }) => {
             return exec(&home, script.as_deref(), &command);
@@ -784,6 +798,130 @@ 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 {
+        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;
+            }
+        }
+        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,
+            })
+        }
+    }
+
+    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() {
+        let Ok(files) = source.discover(home) else {
+            continue;
+        };
+        for file in &files {
+            if limit != 0 && files_read >= limit {
+                break;
+            }
+            let Ok(outcome) = source.read(file) else {
+                continue;
+            };
+            files_read += 1;
+            for trace in &outcome.traces {
+                traces += 1;
+                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 mut classes: Vec<_> = by_class.into_iter().collect();
+    classes.sort_by_key(|(_, t)| std::cmp::Reverse(t.raw));
+    let by_class: Vec<serde_json::Value> = classes
+        .iter()
+        .map(|(k, t)| {
+            let mut row = t.json();
+            row["class"] = serde_json::json!(k);
+            row
+        })
+        .collect();
+    let result = serde_json::json!({
+        "files_read": files_read,
+        "total": total.json(),
+        "by_class": by_class,
+    });
+    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};
 
diff --git a/crates/cli/tests/eval.rs b/crates/cli/tests/eval.rs
new file mode 100644
index 0000000..008f2d3
--- /dev/null
+++ b/crates/cli/tests/eval.rs
@@ -0,0 +1,105 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+use serde_json::{Value, json};
+
+fn home(tag: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("sw-eval-{}-{tag}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(dir.join(".claude").join("projects").join("demo")).unwrap();
+    dir
+}
+
+fn record(kind: &str, content: Value) -> String {
+    json!({
+        "type": kind,
+        "sessionId": "s-1",
+        "timestamp": "2026-10-23T10:00:00Z",
+        "isSidechain": false,
+        "message": { "role": kind, "content": content },
+    })
+    .to_string()
+}
+
+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()
+}
+
+#[test]
+fn eval_reports_reopens_per_command_and_every_block_faithful() {
+    let home = home("report");
+    let session = [
+        record("user", json!("look at the handlers")),
+        record(
+            "assistant",
+            json!([{ "type": "tool_use", "id": "t1", "name": "Bash",
+                     "input": { "command": "cd repo && cat src/handlers.rs" } }]),
+        ),
+        record(
+            "user",
+            json!([{ "type": "tool_result", "tool_use_id": "t1", "content": [
+                { "type": "text", "text": code() },
+                { "type": "image", "source": { "type": "base64", "data": "A".repeat(200_000) } }
+            ] }]),
+        ),
+        record(
+            "assistant",
+            json!([{ "type": "text", "text": "handler 137 reads uniquetoken137" },
+                   { "type": "tool_use", "id": "t2", "name": "Bash", "input": { "command": "ls" } }]),
+        ),
+        record(
+            "user",
+            json!([{ "type": "tool_result", "tool_use_id": "t2", "content": "Cargo.toml\nsrc\n" }]),
+        ),
+    ];
+    std::fs::write(
+        home.join(".claude/projects/demo/s-1.jsonl"),
+        session.join("\n"),
+    )
+    .unwrap();
+    let blocks = home.join("blocks.jsonl");
+
+    let out = Command::new(env!("CARGO_BIN_EXE_secondwind"))
+        .arg("--home")
+        .arg(&home)
+        .args(["eval", "--blocks"])
+        .arg(&blocks)
+        .output()
+        .unwrap();
+    assert!(
+        out.status.success(),
+        "{}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let report: Value = serde_json::from_slice(&out.stdout).unwrap();
+
+    assert_eq!(report["files_read"], 1);
+    assert_eq!(report["total"]["blocks"], 2);
+    assert_eq!(report["total"]["unfaithful"], 0);
+    let cat = report["by_class"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|row| row["class"] == "Bash:cat")
+        .expect("the cat result is classed by its program");
+    assert_eq!(cat["offloaded"], 1);
+    assert_eq!(cat["reopened"], 1);
+    assert!(
+        cat["raw_tokens"].as_u64().unwrap() < 20_000,
+        "the image counts as a placeholder, not its base64"
+    );
+
+    let lines: Vec<Value> = std::fs::read_to_string(&blocks)
+        .unwrap()
+        .lines()
+        .map(|line| serde_json::from_str(line).unwrap())
+        .collect();
+    assert_eq!(lines.len(), 2);
+    assert!(lines.iter().all(|line| line["faithful"] == true));
+}
diff --git a/crates/optimize/src/counterfactual.rs b/crates/optimize/src/counterfactual.rs
index a930117..6e92e8b 100644
--- a/crates/optimize/src/counterfactual.rs
+++ b/crates/optimize/src/counterfactual.rs
@@ -129,6 +129,273 @@ fn references_after(index: &HashMap<String, Vec<usize>>, token: &str, after: usi
         .is_some_and(|turns| turns.iter().any(|&t| t > after))
 }
 
+// One tool result as the optimizer would have handled it, and whether the model later needed what
+// it hid. Only an offload can hide anything: an inline codec keeps every value in view.
+#[derive(Debug, Clone)]
+pub struct BlockOutcome {
+    pub tool: String,
+    pub class: String,
+    pub shape: String,
+    pub outcome: &'static str,
+    pub turn: usize,
+    pub raw_bytes: usize,
+    pub raw_tokens: u64,
+    pub sent_tokens: u64,
+    pub reopened: bool,
+    pub faithful: bool,
+    // Context the model held when it read this result: what one more turn re-reads, from billing.
+    pub context_tokens: u64,
+    // Assistant turns after this result: how many times its tokens are read again.
+    pub turns_after: usize,
+}
+
+// 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
+// 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,
+) -> Vec<BlockOutcome> {
+    let first_seen = first_seen_index(trace);
+    let assistant_tokens = assistant_token_index(trace);
+    let supplied = supply_index(trace);
+    let needed = |tok: &str, ti: usize| {
+        let resupplied = supplied
+            .get(tok)
+            .and_then(|turns| turns.iter().copied().find(|&s| s > ti))
+            .unwrap_or(usize::MAX);
+        assistant_tokens
+            .get(tok)
+            .is_some_and(|turns| turns.iter().any(|&t| t > ti && t < resupplied))
+    };
+    let calls: HashMap<&str, (&str, &str)> = trace
+        .turns
+        .iter()
+        .flat_map(|turn| &turn.segments)
+        .filter_map(|segment| match &segment.kind {
+            SegmentKind::ToolCall { name, id: Some(id) } => {
+                Some((id.as_str(), (name.as_str(), segment.effective.as_str())))
+            }
+            _ => None,
+        })
+        .collect();
+
+    let mut next_context = vec![0u64; trace.turns.len()];
+    let mut assistant_after = vec![0usize; trace.turns.len()];
+    let mut seen = 0;
+    let mut later = 0;
+    for (ti, turn) in trace.turns.iter().enumerate().rev() {
+        assistant_after[ti] = later;
+        if turn.role == Role::Assistant {
+            later += 1;
+        }
+        if let Some(b) = turn.billing.filter(|_| turn.role == Role::Assistant) {
+            seen = b.input_tokens
+                + b.cache_read_tokens
+                + b.cache_write_5m_tokens
+                + b.cache_write_1h_tokens;
+        }
+        next_context[ti] = seen;
+    }
+
+    let mut out = Vec::new();
+    for (ti, turn) in trace.turns.iter().enumerate() {
+        for segment in &turn.segments {
+            let SegmentKind::ToolResult { tool, id } = &segment.kind else {
+                continue;
+            };
+            let body = segment.original.as_deref().unwrap_or(&segment.effective);
+            if body.is_empty() {
+                continue;
+            }
+            let input = id.as_deref().and_then(|id| calls.get(id)).map(|c| c.1);
+            let raw_tokens = counter.count(body) as u64;
+            // 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) {
+                crate::Outcome::Compressed { wire, .. } => {
+                    let ok = crate::certificate::verify(&wire, &crate::certificate::certify(body));
+                    ("inline", wire, None, ok)
+                }
+                crate::Outcome::Offloaded { stub, marker, .. } => {
+                    let ok = optimizer
+                        .resolve(&marker)
+                        .is_some_and(|back| same_content(&back, body));
+                    ("offload", stub.clone(), Some(stub), ok)
+                }
+                crate::Outcome::KeptVerbatim { .. } => ("verbatim", body.to_string(), None, true),
+            };
+            let reopened = hidden_from.is_some_and(|stub| {
+                residual_tokens(body, &stub)
+                    .iter()
+                    .any(|tok| first_seen.get(tok) == Some(&ti) && needed(tok, ti))
+            });
+            out.push(BlockOutcome {
+                tool: tool.clone(),
+                class: command_class(tool, input),
+                shape: classify(body),
+                outcome,
+                turn: ti,
+                raw_bytes: body.len(),
+                raw_tokens,
+                sent_tokens: counter.count(&sent) as u64,
+                reopened,
+                faithful,
+                context_tokens: next_context[ti],
+                turns_after: assistant_after[ti],
+            });
+        }
+    }
+    out
+}
+
+// Byte-identical text, or JSON holding the same value; an offload stores JSON canonicalized.
+fn same_content(back: &str, original: &str) -> bool {
+    if back == original {
+        return true;
+    }
+    match (
+        serde_json::from_str::<serde_json::Value>(back),
+        serde_json::from_str::<serde_json::Value>(original),
+    ) {
+        (Ok(a), Ok(b)) => a == b,
+        _ => false,
+    }
+}
+
+// What produced a result: the tool, and for a shell call the program whose output it is.
+pub fn command_class(tool: &str, input: Option<&str>) -> String {
+    if tool != "Bash" {
+        return tool.to_string();
+    }
+    let command = input
+        .and_then(|raw| serde_json::from_str::<serde_json::Value>(raw).ok())
+        .and_then(|v| v["command"].as_str().map(str::to_string))
+        .unwrap_or_default();
+    let command = without_heredoc_bodies(&command);
+    let words: Vec<&str> = command
+        .split(|c: char| c.is_whitespace() || c == ';')
+        .collect();
+    let opens_loop = words
+        .iter()
+        .any(|w| matches!(*w, "for" | "while" | "until"));
+    if opens_loop && words.contains(&"do") || words.first() == Some(&"if") {
+        return "Bash:loop".to_string();
+    }
+    let last = command
+        .split(['\n', ';'])
+        .flat_map(|part| part.split("&&"))
+        .flat_map(|part| part.split("||"))
+        .map(str::trim)
+        .filter(|part| {
+            let head = part.split_whitespace().next().unwrap_or("");
+            !part.is_empty()
+                && !head.starts_with('#')
+                && !matches!(
+                    head,
+                    "cd" | "echo" | "printf" | "export" | "set" | "source" | "true" | "sleep"
+                )
+        })
+        .last()
+        .unwrap_or("");
+    let first_stage = last.split('|').next().unwrap_or("").trim();
+    let mut words = first_stage
+        .split_whitespace()
+        .skip_while(|w| {
+            (w.contains('=') && !w.starts_with('-'))
+                || matches!(*w, "sudo" | "time" | "nohup" | "env" | "command")
+        })
+        .peekable();
+    if words.peek() == Some(&"timeout") {
+        words.next();
+        words.next();
+    }
+    let program = words
+        .next()
+        .unwrap_or("")
+        .trim_matches(['"', '\''])
+        .rsplit('/')
+        .next()
+        .unwrap_or("");
+    let program = match program {
+        "" => return "Bash:other".to_string(),
+        "python" | "python3" | "uv" | "npx" | "bunx" => {
+            let next = words
+                .find(|w| !w.starts_with('-') && !w.starts_with('<'))
+                .unwrap_or("-");
+            return format!("Bash:{program} {}", next.rsplit('/').next().unwrap_or(""));
+        }
+        "git" | "cargo" | "npm" | "gh" | "pnpm" | "bun" | "docker" | "kubectl" => {
+            let mut sub = "";
+            while let Some(w) = words.next() {
+                if matches!(
+                    w,
+                    "-C" | "-c" | "--git-dir" | "--work-tree" | "--manifest-path"
+                ) {
+                    words.next();
+                } else if !w.starts_with('-') {
+                    sub = w;
+                    break;
+                }
+            }
+            return format!("Bash:{program} {sub}");
+        }
+        other => other,
+    };
+    let piped = if last.contains('|') { " |" } else { "" };
+    format!("Bash:{program}{piped}")
+}
+
+// Drops the body of every `<<WORD` heredoc so its lines are not read as commands.
+fn without_heredoc_bodies(command: &str) -> String {
+    let mut out = String::new();
+    let mut end: Option<String> = None;
+    for line in command.lines() {
+        if let Some(word) = &end {
+            if line.trim() == word {
+                end = None;
+            }
+            continue;
+        }
+        out.push_str(line);
+        out.push('\n');
+        if let Some(at) = line.find("<<") {
+            let word: String = line[at + 2..]
+                .trim_start_matches('-')
+                .trim_start()
+                .trim_start_matches(['\'', '"'])
+                .chars()
+                .take_while(|c| c.is_alphanumeric() || *c == '_')
+                .collect();
+            if !word.is_empty() {
+                end = Some(word);
+            }
+        }
+    }
+    out
+}
+
+// Turns where a token reaches the model from outside: tool results and user messages.
+fn supply_index(trace: &Trace) -> HashMap<String, Vec<usize>> {
+    let mut index: HashMap<String, Vec<usize>> = HashMap::new();
+    for (ti, turn) in trace.turns.iter().enumerate() {
+        if turn.role == Role::Assistant {
+            continue;
+        }
+        let mut seen = HashSet::new();
+        for segment in &turn.segments {
+            for tok in significant(&segment.effective) {
+                if seen.insert(tok) {
+                    index.entry(tok.to_string()).or_default().push(ti);
+                }
+            }
+        }
+    }
+    index
+}
+
 fn classify(body: &str) -> String {
     if body.contains("diff --git") {
         "diff".to_string()
@@ -203,6 +470,119 @@ mod tests {
         out
     }
 
+    // A body the optimizer offloads as a code outline, so later lines stay hidden.
+    fn code_body() -> 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 evaluated(turns: Vec<Turn>) -> Vec<BlockOutcome> {
+        let mut optimizer = crate::Optimizer::default();
+        evaluate(&trace(turns), &mut optimizer, &crate::tokens::ByteCounter)
+    }
+
+    #[test]
+    fn eval_charges_a_reopen_to_the_result_that_hid_the_token() {
+        let out = evaluated(vec![
+            tool_turn(0, &code_body()),
+            assistant_turn(1, "I will use uniquetoken137 from the results"),
+        ]);
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].outcome, "offload");
+        assert!(out[0].reopened);
+        assert!(out[0].faithful);
+        assert!(out[0].sent_tokens < out[0].raw_tokens);
+    }
+
+    #[test]
+    fn eval_charges_a_later_result_that_supplies_the_token_again() {
+        let out = evaluated(vec![
+            tool_turn(0, &code_body()),
+            tool_turn(1, "the file holds uniquetoken137 on its first line"),
+            assistant_turn(2, "I will use uniquetoken137 from the file"),
+        ]);
+        assert_eq!(out[0].outcome, "offload");
+        assert!(!out[0].reopened, "the model read it from the second result");
+    }
+
+    #[test]
+    fn every_shape_the_optimizer_touches_is_faithful() {
+        let json = format!(
+            "[{}]",
+            (0..60)
+                .map(|i| format!(
+                    r#"{{"id":{i},"name":"item {i}","tags":["a","b"],"score":{i}.5}}"#
+                ))
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        let log: String = (0..300)
+            .map(|i| {
+                format!(
+                    "2026-10-23T01:{:02}:00Z INFO worker-{} handled job {i} in {}ms\n",
+                    i % 60,
+                    i % 7,
+                    i * 3
+                )
+            })
+            .collect();
+        let out = evaluated(vec![
+            tool_turn(0, &json),
+            tool_turn(1, &log),
+            tool_turn(2, &big_search_body("needle")),
+        ]);
+        assert_eq!(out.len(), 3);
+        for block in &out {
+            assert!(block.faithful, "{} came back different", block.outcome);
+        }
+        assert!(out.iter().any(|b| b.outcome != "verbatim"));
+    }
+
+    #[test]
+    fn same_content_accepts_reformatted_json_and_nothing_else() {
+        assert!(same_content(
+            r#"{"a":1,"b":[2,3]}"#,
+            "{ \"b\": [2, 3], \"a\": 1 }"
+        ));
+        assert!(same_content("plain text\n", "plain text\n"));
+        assert!(!same_content("plain text", "plain text\n"));
+        assert!(!same_content(r#"{"a":1}"#, r#"{"a":2}"#));
+    }
+
+    #[test]
+    fn command_class_names_the_program_whose_output_it_is() {
+        let class = |command: &str| {
+            command_class(
+                "Bash",
+                Some(&serde_json::json!({ "command": command }).to_string()),
+            )
+        };
+        assert_eq!(class("cd repo && cat src/main.rs"), "Bash:cat");
+        assert_eq!(class("grep -rn foo src | head -40"), "Bash:grep |");
+        assert_eq!(class("git -C repo log --oneline -5"), "Bash:git log");
+        assert_eq!(
+            class("RUST_LOG=1 timeout 60 cargo test -p x"),
+            "Bash:cargo test"
+        );
+        assert_eq!(class("\"$HOME/bin/tool\" --flag"), "Bash:tool");
+        assert_eq!(
+            class("python3 - <<'EOF'\nimport os\nprint(os.getcwd())\nEOF"),
+            "Bash:python3 -"
+        );
+        assert_eq!(
+            class("cat > f.txt <<EOF\nfor x in y; do\nEOF\nwc -l f.txt"),
+            "Bash:wc"
+        );
+        assert_eq!(class("cd x; for f in *.rs; do wc -l $f; done"), "Bash:loop");
+        assert_eq!(class("echo hi"), "Bash:other");
+        assert_eq!(command_class("Read", None), "Read");
+    }
+
     #[test]
     fn residual_referenced_later_counts_as_a_reopen() {
         let body = big_search_body("uniquetoken");