Terminal-Bench 2.1 through Claude Code · September 27 and 28, 2026
61, 60 and 59 of 89 tasks resolved, within single-trial noise, and 29% fewer provider-reported input tokens for Gobstopper at its default tail than for Claude Code with no proxy.
We benchmarked our own default, and it lost. In total, the old default, tail 40, cost 39% more than tail 0 and 17% more than no proxy in provider-reported terms, so v0.7.3 makes tail 0 the default. These are ratios of totals from one trial per task, not per-task effects. Tail 0 against tail 40 is the only cost comparison whose interval excludes zero (tail 0 cost 28% less, 95% interval −46.5% to −1.6%), and only just. Five tasks drive it, and one task accounts for $1.02 of the $2.25 gap. Host load of 58 to 68 during the tail 40 arm is a confound.
Setup
- Benchmark: Terminal-Bench 2.1, 89 tasks, one trial per task per arm, on harbor 0.23.0 with 3 concurrent trials and up to 2 retries.
- Agent: Claude Code 2.1.283.
- Model: GLM 5.3 Flash through Vercel AI Gateway, in the Anthropic Messages format.
- Proxy: a 45,000-token threshold (estimated; the default is 128,000), calibration on, a 24,000-character carry, and the last 3 turns kept.
- Arms, in run order: Gobstopper, tail 0, then Gobstopper, tail 40 (old default), then Claude Code, no proxy.
- Build: Gobstopper v0.7.2. 21 of 89 tail 0 trials started before a proxy restart and may have run an earlier build; their logs were lost in a host reboot. All tail 40 trials ran on v0.7.2.
- Host: one Apple-silicon Mac with a Colima VM of 5 CPUs and 6 GiB, x86 task images under Rosetta emulation, host load 58 to 68 during the tail 40 arm.
- Dates: September 27, 16:18 UTC to September 28, 15:53 UTC; 9.2, 8.0 and 6.3 hours of wall time for the three arms in run order.
| Arm | Resolved (Wilson 95%) | Total input | Cache read | Uncached input | Output | Provider-reported cost | Per task |
|---|---|---|---|---|---|---|---|
| Gobstopper, tail 0 | 61 (58.3 to 77.2) | 84.31M | 68.69M | 15.61M | 2.64M | $5.72 | $0.064 |
| Claude Code, no proxy | 60 (57.1 to 76.3) | 118.55M | 102.64M | 15.91M | 2.71M | $6.82 | $0.077 |
| Gobstopper, tail 40 (old default) | 59 (56.0 to 75.3) | 118.48M | 98.23M | 20.25M | 3.97M | $7.97 | $0.090 |
Paired statistics
Each pair compares the same 89 tasks: an exact McNemar test on resolved tasks, and a 20,000-sample paired bootstrap for the resolve-rate difference and the change in total cost. Only the total-cost change for tail 0 against tail 40 excludes zero, and only just; no resolve-rate difference does.
| Pair | McNemar p | Resolved, difference in points | Total cost, change |
|---|---|---|---|
| Gobstopper, tail 0 against Gobstopper, tail 40 (old default) | 0.82 | +2.25 (−7.87 to +12.36) | −28.2% (−46.5% to −1.6%) |
| Gobstopper, tail 0 against Claude Code, no proxy | 1.00 | +1.12 (−8.99 to +11.24) | −16.1% (−31.8% to +1.9%) |
| Gobstopper, tail 40 (old default) against Claude Code, no proxy | 1.00 | −1.12 (−11.24 to +8.99) | +16.9% (−14.4% to +59.6%) |
Figures
Solved about as often
Gobstopper, tail 0
61 of 89 · 58.3–77.2%
Claude Code, no proxy
60 of 89 · 57.1–76.3%
Gobstopper, tail 40 (old default)
59 of 89 · 56.0–75.3%
The intervals overlap almost completely: no measurable difference (McNemar p = 1.0 against no proxy). 31 of 89 tasks changed outcome between arms, the noise level of one trial.
Show the numbers
| Arm | Solved of 89 | Rate | 95% interval |
|---|---|---|---|
| Gobstopper, tail 0 | 61 | 68.5% | 58.3–77.2% |
| Claude Code, no proxy | 60 | 67.4% | 57.1–76.3% |
| Gobstopper, tail 40 (old default) | 59 | 66.3% | 56.0–75.3% |
29% fewer input tokens in one benchmark
- cache reads (context re-sent)
- new input (not cached)
Provider-reported cost for this model: $0.064, $0.077 and $0.090 per task. The 16% gap to no proxy is not statistically significant (95% interval −32% to +2%).
Show the numbers
| Arm | Solved of 89 | Total input | Cache reads | New input |
|---|---|---|---|---|
| Gobstopper, tail 0 | 61 | 84.3M | 68.7M | 15.6M |
| Claude Code, no proxy | 60 | 118.6M | 102.6M | 15.9M |
| Gobstopper, tail 40 (old default) | 59 | 118.5M | 98.2M | 20.3M |
31 of 89 tasks changed outcome between arms
- 43 solved by all three arms
- 31 changed between arms
- 15 solved by none
Show the numbers
| Outcome | Tasks |
|---|---|
| solved by all three arms | 43 |
| changed between arms | 31 |
| solved by none | 15 |
Cost terms
Vercel AI Gateway prices for GLM 5.3 Flash, $0.15 per million uncached input tokens, $0.03 per million cache reads and $0.50 per million output tokens, reproduce every trial's provider-reported cost exactly. This route recorded no cache writes. Anthropic prices cache reads at 0.1× input and bills cache writes, so the same token cut is worth a different share of the cost there, and subscriptions are not billed per token. Timed-out trials are cut short, so their costs are partial.
Five tasks carried the old default's extra cost
video-processing
winning-avg-corewars
path-tracing-reverse
path-tracing
schemelike-metacircular-eval
other 84 tasks
Show the numbers
| Task | Tail 40 minus tail 0 |
|---|---|
| video-processing | +$1.02 |
| winning-avg-corewars | +$0.52 |
| path-tracing-reverse | +$0.29 |
| path-tracing | +$0.29 |
| schemelike-metacircular-eval | +$0.25 |
| other 84 tasks | −$0.12 |
What the proxies did
With Gobstopper, tail 0, the proxy compacted 64 requests and reused a compacted prefix for 524 more in the logged part of the arm, about 68 of 89 trials; a host reboot removed the earlier log. The median reused request went from 62K to 36K estimated tokens. With Gobstopper, tail 40 (old default), it compacted 178 and reused 1,363, and 3 requests were still over the threshold after compaction (0 with tail 0). No request fell back to its original bytes. The provider returned 3 upstream faults across both arms.
Against the paper
CliffCompaction's authors report 76.69 ± 1.41% for 45K CliffCompaction, 73.03 ± 3.04% for 200K native summarization and 70.97 ± 3.72% for 45K native autocompact (arXiv:2609.26779), their figures, not ours. Our run used a different model and host, so compare directions only. Here, Gobstopper at tail 0 resolved 68.5% against 67.4% with no proxy, within single-trial noise. Our absolute rates are lower than theirs, likely because of 18 to 19 agent timeouts per arm under emulation and host load; that is inferred, not measured. This run had no 45K native auto-compaction arm, so it has no counterpart to their third row.
Replay grid
Estimates, main fdeb099, September 26
Over 24 recorded sessions (12 Claude Code, 12 Codex; 288 settings), replay cut cumulative estimated input by 78% at a 32K threshold and 61% at 128K, with 0 unpaired tool calls. These are estimates at four characters per token, not billed tokens, from a build older than the live run. Three large sessions hold 476M of the 665M tokens, so the typical session cut at 32K is about 46%. At 128K the median Claude Code session is not cut at all, because most never cross it. Keeping 40% of the tail instead of none raised estimated cache reads at every threshold, from 129.1M to 130.4M at 32K and from 254.3M to 279.6M at 128K. Repeated reads still covered at 32K: 38 to 39 of 57 for Claude Code and 22 to 23 of 28 for Codex.
Lower thresholds cut more
- Gobstopper, tail 0
- Gobstopper, tail 40
0 unpaired tool calls in 288 replays. Three large sessions hold 476M of the 665M tokens, so a typical session's cut at 32K is about 46%. At 128K most Claude Code sessions never cross the threshold.
Show the numbers
| Threshold | Tail 0 | Tail 25 | Tail 40 |
|---|---|---|---|
| 32K | 78.4% | 78.4% | 78.1% |
| 64K | 73.2% | 72.8% | 71.7% |
| 128K | 60.8% | 59.1% | 56.8% |
| 256K | 37.9% | 35.3% | 32.3% |
A sawtooth, not a ramp
- Claude Code, no proxy
- Gobstopper, tail 0
- threshold: 45K set, lowered by calibration
- no proxy: up to 491K per request
- 50 rewrites
- total over the session: 116.7M to 12.9M estimated tokens (89% less)
Show the numbers
| Measure | Claude Code, no proxy | Gobstopper, tail 0 |
|---|---|---|
| Requests | 383 | 383 |
| Largest request | 491K | 39K |
| Total over the session | 116.7M | 12.9M |
| Rewrites | 0 | 50 |
A larger recent tail leaves less room before the next rewrite
less room left, so the next rewrite comes sooner
Gobstopper, tail 0 (default)
- last 3 turns
- summary of the middle
- your task
Gobstopper, tail 40 (larger tail)
- last 3 turns
- older turns kept
- summary of the middle
- your task
What this run does not show
- It is one trial per arm, so the resolved counts cannot separate the arms.
- It used one model, and not an Anthropic model.
- The threshold was 45,000 tokens, not the 128,000 default; quality at 128K was not measured live.
- Tasks ran under emulation on a shared host, with timeouts in every arm.
- Up to 21 tail 0 trials may have run an earlier build.
- There was no 45K native auto-compaction arm.
- It makes no subscription or billing claim.
Downloads
terminal-bench-results.json: per-arm totals, the three paired comparisons, task churn, cost concentration, per-task outcomes and costs, proxy activity, and the protocol.replay-grid.json: the 288-cell replay grid, pooled and by provider only.sawtooth-series.json: per-request estimated sizes for the one session in the sawtooth figure.
The files hold aggregate counts, per-task outcomes and the protocol. They contain no transcripts, keys or machine paths.
729-session retrospective · September 19, 2026
36.4% median projected context reduction across 73 high-context archived Codex root tasks, with 76.9% sampled-string retention. All 73 produced portable compacted plans. It was an offline replay on one Mac with deterministic rules, so it did not measure billing savings, successful continuation, or model quality.
Across all 729 sessions, 92 produced plans and 637 produced no plan, and the overall median reduction was 0%. Every median in the table includes no-plan cases, so the root-task result does not describe every session.
| Cohort | Sessions | Plans | No plan | Median reduction |
|---|---|---|---|---|
| Archived Codex roots, high context | 73 | 73 | 0 | 36.44% |
| Codex subagents, high context | 512 | 2 | 510 | 0% |
| Claude sessions, high context | 23 | 17 | 6 | 14.85% |
| Below-trigger controls, all cohorts | 121 | 0 | 121 | 0% |
| All selected sessions | 729 | 92 | 637 | 0% |
Retention and recovery
On the 73 root rewrites, 3,664 of 4,762 sampled strings survived; 1,098 were absent from the smaller context. Literal matching does not tell us which missing strings matter for the next task. Snapshots make the source history available for explicit recovery; they do not guarantee automatic recall or task success.
All 122 selected protected-tail probes survived, but only 31 of the 73 root rewrites had any such probes. Root baselines and rewritten files had no structural errors. Across the whole study, verifier severity/code counts did not increase; one pre-existing error persisted in a rewritten Claude sample. Structural checks do not prove that a fork will resume successfully.
What was tested
Five strategies produced 3,645 evaluations with zero evaluation failures. The policy used an 80,000-token trigger, a 40,000-token target, eight recent outputs protected, and 4,096 minimum estimated savings. Projected reductions apply to the live context after the latest native boundary, not the complete on-disk history. Among 57 high-context roots with earlier native compaction, the median projected reduction was 36.05%.
The first cohort contained 576 Codex subagents and 39 Claude histories. A separate archive audit selected 114 roots: 73 above the trigger and 41 controls. It excluded 31 roots over 128 MiB and one without usable current usage. The cohorts did not overlap by session identity or exact event body. Selection was registered before compaction outcomes; the earlier six-root pilot is excluded.
These tasks came from one person's Mac and can share prompts, projects and unobserved ancestry. The size limit excludes some long tasks. No provider continuation, remote scorer, semantic judge, billing, cache benefit, or recovery-time comparison was run. The study was not compared with fast-jev-compaction, a third-party Claude Code plugin that uses Jev to decide which tool output to drop.
The measured evaluator could emit 65–67 probes despite a nominal 64-probe limit. The counts here are the actual measured counts. The later cap correction does not retroactively change this study. The downloads identify the measured source commit and executable hash.
Download the data
- Study report (Markdown)
- Aggregate results for all five strategies (JSON)
- Selection and analysis protocol (JSON)
Downloads contain aggregate statistics and methodology only. Private transcripts, session identifiers, file paths, per-session hashes and per-session results are excluded. The private corpus cannot be independently replayed from these downloads.
Keep-score cutoff comparison · September 19, 2026
A separate paired replay tested an optional keep-score cutoff on the same 114 archived roots: 73 high-context tasks and 41 controls. It used scored with the deterministic heuristic and the corrected 64-probe limit. It compares policies on the same sample; it is not a new sample, a held-out validation, or a comparison of model backends.
The 0.35 cutoff raised sampled-string retention from 77.05% to 80.78%, while median projected reduction fell from 36.44% to 34.96%. Forty of 73 tasks retained more sampled strings and none retained fewer. Two tasks produced no plan; their retention is derived from leaving the source unchanged. The cutoff trades a little size reduction for retention. The run did not test task success and was not compared with fast-jev-compaction.
| Variant | Plans / no plan | Median reduction | Literal retention | Tasks improved / declined |
|---|---|---|---|---|
| Baseline, cutoff disabled | 73 / 0 | 36.44% | 3,596 / 4,667 (77.05%) | 0 / 0 |
| Candidate, cutoff disabled | 73 / 0 | 36.44% | 3,596 / 4,667 (77.05%) | 0 / 0 |
| Cutoff 0.35 | 71 / 2 | 34.96% | 3,770 / 4,667 (80.78%) | 40 / 0 |
| Cutoff 0.5 | 73 / 0 | 36.35% | 3,614 / 4,667 (77.44%) | 11 / 0 |
| Cutoff 0.65 | 73 / 0 | 36.44% | 3,598 / 4,667 (77.09%) | 1 / 0 |
Retention counts use the same 4,667 baseline probes in every row; improved and declined task counts compare literal retention with that baseline. The two unchanged-source cases at 0.35 are included in those totals. Controls had no reported literal-probe result. This corrected probe set differs from the 4,762 probes in the original study above; the two retention percentages cannot be compared as a policy effect.
All 570 evaluations completed without failures. With the cutoff disabled, candidate and baseline plans and probe results matched across all 114 sessions. Every variant left all 41 below-trigger controls unchanged. No new verifier error or warning counts were observed, and frozen inputs were checked before and after replay. Structural checks still do not prove successful provider resume.
All three cutoffs were registered before this run's outcomes, after the original baseline was already known; none is a tuned recommendation based on held-out task performance. The feature remains opt-in for scored, and defaults are unchanged. Literal matching does not establish semantic importance, correct continuation, billing savings, or automatic recovery. No local or remote model was called. Timing in the downloads is descriptive under shared host load.
The downloads identify the measured baseline and candidate executables. The candidate was a local build of the reviewed cutoff patch on main commit ded1d0c, separate from the baseline installed when this experiment ran. Downloads exclude private transcripts, session identifiers, paths, corpus manifests and per-session records.
On-device Apple scorer pilot · September 19, 2026
A separate mechanism check used three frozen, convenience-selected Codex root-task inputs from one Mac, excluded from the 729-session study. It compared the deterministic heuristic with an on-device Apple Intelligence scorer that adjusts the heuristic's scores. Both used scored and a 0.5 keep-score cutoff. The pilot checks that this configuration runs; it does not measure model quality.
| Scorer | Plans / no plan | Median projected reduction | Literal retention | Median wall time |
|---|---|---|---|---|
| Deterministic heuristic | 3 / 0 | 50.35% | 148 / 192 | 0.090 s |
| Apple overlay (on-device) | 1 / 2 | 0% | 192 / 192 | 11.912 s |
Of Apple's 192 retained probes, 128 are derived from the two unchanged no-plan inputs; 64 were checked against its one rewritten output. Apple reclaimed only 5,574 projected tokens in total, versus 323,532 for the heuristic. It was more conservative and took longer in this pass. This is not evidence of a better compaction policy or more successful continuation.
The model made 12 on-device calls and supplied 92 of 92 selected score overlays, with no failed batches or fallback diagnostics. Coverage was capped at 32 candidates per input, and candidates beyond the cap kept their heuristic scores by design, not because a call failed. No remote model was called.
All six evaluations completed without failures, source inputs and executables stayed unchanged, and verifier error/warning counts did not increase. The three available protected-tail probes survived under both variants, but only two inputs had such probes. There was no provider resume, task-success test, billing measurement, repeatability trial, or model cold/warm control. Wall times are descriptive observations from one pass.
The results file records the SHA-256 of the measured Gobstopper executable and of the local Apple bridge. It excludes per-input records and hashes, identifiers, private paths, prompts, and model responses.
Snapshot search and recovery · September 20, 2026
Gobstopper found all 108 predeclared search targets and recovered all 108 target records byte for byte in a public synthetic API study. All 553 checks passed. These are known-query recovery checks, not agent task-quality results.
The corpus contains 36 snapshots: 18 in Codex format and 18 in Claude Code format, with six families per provider and three versions per family. A separate malformed-record fixture tests error accounting. Related versions are test cases, not independent real tasks. The synthetic corpus is separate from the private session studies above.
| Check group | Passed / total |
|---|---|
| Known-target search | 108 / 108 |
| Byte-exact record recovery | 108 / 108 |
| Absent, case, key and version isolation queries | 144 / 144 |
| Result limits and truncation counts | 36 / 36 |
| Candidate state-card queries | 108 / 108 |
| Baseline vault-format compatibility | 36 / 36 |
| Invalid-input, integrity, pagination, and MCP safeguards | 13 / 13 |
| All checks | 553 / 553 |
Half the snapshots encode Unicode as JSON escapes; six place a target record across a vault chunk boundary. Recovery reconstructs long records through 4 KiB pages. The checks also cover corruption rejection, metadata-only search results, and MCP tools that expose transcript content only after explicit enablement.
The state-card recall command found 18 of 108 declared field queries in the baseline build and 108 of 108 in the candidate, which added portable Codex-card handling and searches the error and current-work fields. The baseline did not have the search-snapshot and read-snapshot commands; those are recorded as unsupported capabilities, not retrieval failures or a speed comparison.
Queries, expected bytes, and limits were fixed before execution. All 989 commands completed within the registered bounds; frozen fixtures, vault contents and pinned executables stayed unchanged. No local model, remote model or provider service was called. Runtime figures in the results file describe one pass on one machine.
The vault was seeded directly, so this study does not test snapshot creation or whether compaction supplies the correct recovery pointer. Known queries do not test an agent's ability to notice missing information, choose useful searches, or finish a task. This is not a semantic-recall, provider-resume, compaction-savings, or matched Jev benchmark.
- Recovery results and check counts (JSON)
- Frozen recovery protocol (JSON)
- Public fixture generator and reproduction instructions
Downloads contain aggregate checks, methodology and measured executable hashes. They contain no private transcripts, per-case records, machine paths or bundled executables.
Request proxy · recorded September 25 and 26, 2026
On September 25, gobstopper proxy replay, built from the main branch that day, ran nine recorded sessions from one Mac through the proxy engine with three kept turns, the default on that date. Six Claude Code sessions whose requests peaked at 273k to 652k estimated tokens stayed at or under about 127k, and one Codex session that peaked at 242k stayed under about 127k. Two Codex sessions that Codex had already compacted itself began with heads near 160k and stayed under about 243k. No replayed request was left with an unpaired tool call.
On September 26, the same Mac sent about 77 minutes of Claude Code traffic through gobstopper proxy serve from the v0.4.1 release at its defaults. Of 3,136 requests, most were small (median about 6,300 estimated tokens). 89 passed the 128,000-token threshold; the proxy sent 78 of them smaller, 12.2 million estimated tokens in total down to 7.5 million (38% less). The other 11 went out unchanged; v0.4.1 does not record why, and the likely cause is a threshold raised by a large verbatim head. The current build records the threshold applied to each request. There were no provider errors and no length retries.
Both are estimates at four characters per token from one machine, not billed tokens, cache hit rates, or task results. CliffCompaction's authors report cost and benchmark results for their proxy on the comparison page. Gobstopper has not rerun the authors' benchmarks as published; its own Terminal-Bench run is above.
Synthetic strategy benchmark
cargo run --example bench_strategies --release generates synthetic Codex transcripts with varying tool-output history and prints a CSV of actual byte reduction, projected token reduction, elapsed time, and structural integrity per strategy.
Historical live trials · recorded September 17, 2026
The trials below were recorded in the repository on September 17. They are separate single-session experiments using earlier builds and workflows, not validation of the 729-session replay or a current provider-wide performance guarantee. Their accuracy judgments concern the specific resume question shown, not general task completion.
How the live trials worked
These comparisons resumed real sessions after compaction. The tables report answers to resume questions and observed provider tokens. Some also include cache counters or transcript record changes. Task completion, latency, and re-fetch rates require separate measurements.
One Claude session: live API token comparison
The same 333k-token Claude session was restored from the gobstopper vault and asked the same resume question under four conditions. The question was: "What were we working on? Briefly state the current task and the most recent concrete decision or conclusion, if any." Token numbers are the observed provider usage for the resume turn (input = cache read + cache creation + uncached input; output = response tokens).
| condition | input tokens | output tokens | recalled the standing task? |
|---|---|---|---|
| none (original) | 312,722 | 1,405 | yes: npm unification and stalled renames |
Gobstopper elide | 219,167 | 1,052 | yes: same standing task, stalled renames |
Gobstopper compacted | 220,447 | 621 | yes: same standing task from the state-card digest |
Claude --autocompact 100 | 56,300 | 416 | no: incorrectly claimed the renames were already done and published |
Gobstopper's elide and compacted both cut the resume context by about 30% while keeping the answer accurate. Claude's native --autocompact 100 cut the resume context by ~82% but produced a confident, inaccurate summary of the session.
One Codex session: resume token comparison
The same resume question was asked on a 101k-token Codex session (a real BEAM-benchmark thread) under three conditions. Provider-native Codex compaction was not included in this historical trial.
| condition | input tokens | output tokens | recalled the standing task? |
|---|---|---|---|
| none (original) | 101,275 | 244 | yes: Oh's memory benchmark and the 0.60 expansion gate |
Gobstopper elide | 57,980 | 83 | yes: same 0.545 score and 0.60 gate |
Gobstopper compacted | 34,503 | 159 | yes: same BEAM experiment and expansion gate |
On Codex, compacted cut resume input tokens by 66% andelide cut them by 43%, both with accurate answers. gobstopper diff compares two vault snapshots structurally, so you can check what a strategy removed before you rely on it.
One Claude session: prefix preservation and provider cache
The cache_aware strategy elides the latest stale tool outputs before the protected tail instead of the oldest, so the conversation prefix stays byte-identical. On a 339k-token Claude session at a 310k floor, the same resume question was asked under three conditions, restoring the same session between runs with the earlier experimental workflow. Current undo restores a Claude Code or Codex session into a separate fork and has no in-place mode. The provider's real cache counters were read from the API response:
| condition | cache read | cache creation | file prefix preserved | cost | accurate? |
|---|---|---|---|---|---|
| none (original) | 10,010 | 325,647 | n/a | $6.53 | yes |
Gobstopper cache_aware | 13,536 | 258,517 | 107,884 tokens | $5.19 | yes |
Gobstopper compacted | 13,536 | 257,505 | 6,639 tokens | $5.18 | yes |
All three answers were accurate. Both strategies cut cache-write tokens by ~21% (~20% lower cost on the resume turn). Both compacted conditions recorded 13,536 cache_read tokens, versus 10,010 in the baseline, so the extra prefix preservation does not translate into more provider cache hits in this trial. The preserved file prefix is an auditability result; these measurements do not establish future cache or billing benefits.
Historical transcript structure check
| intervention | records | removed | added | resumed? |
|---|---|---|---|---|
| original session | 5,244 | n/a | n/a | yes |
Claude --autocompact 100 | 5,303 | 0 | 59 | yes |
Gobstopper compacted | 5,247 | 43 | 46 (43 stubs + 3 digest) | yes |
On the same 333k-token real Claude session, native --autocompact 100appended 59 records and removed none. The earlier Gobstopper experiment replaced 43 stale tool outputs and injected a resumable state-card digest, and claude --resume succeeded with the model recalling the last user prompt and current task state. gobstopper diff reports this kind of structural change between two vault snapshots.