v0.8.0

Fewer tokens from the session itself, not only from tool output: screenshots are downscaled in the Claude hook,
piped commands are optimized, output budgets tighten when the context grows large, and a failed source no longer
bypasses optimization forever. 30 new dialects and fixes, a costs and context view in the dashboard, and a project
config file.

Added

• Claude hook: image Reads above max_image_pixels are downscaled, keeping the result's shape and the original
  in the ledger. Pipelines that end in grep, jq, sort, wc and the like are optimized, with the exit status
  of the whole pipeline kept.
• Claude hook: a context-size note on prompt submit above a threshold ($GASCOIGNE_CONTEXT_NUDGE, off to
  disable; nothing is forced), and tighter truncate, log and grep budgets once the context is large.
• MCP results from the PostToolUse hook carry the call's url and query, as in the LLM proxy, so fetch-like
  results are typed and sampled for the query. mcp-proxy can trim tool descriptions (trim_descriptions) and
  takes manual rules; fetch answers a repeated URL with a pointer or a diff.
• opencode: tool.execute.after shortens what the rewrite missed.
• .gascoigne.yaml, searched from the working directory up to the git root, lays over the user config for
  exec and the hooks; each repo gets its own warm pipeline.
• Dialects: Node/Deno/Bun stack frames; JSON diagnostics from cargo, eslint, ruff, golangci-lint, mypy and
  pylint; kubectl apply|delete|rollout status; dmesg; text lockfiles (pnpm, pubspec, mix, Podfile,
  Package.resolved, bun); dependency trees (npm ls, pnpm why, cargo tree, pipdeptree, uv tree, gradle
  and more); coverage tables (coverage report, nyc report, c8 report, jest); docker pull|push; git reflog, stash list,
  tag, remote -v and a bare diff --stat; terraform init, state list, validate; web search results;
  system commands (free, vmstat, findmnt, w); package inventories (pip list,
  pacman -Q, brew list); the make eval table; show for more languages.
• truncate keeps lines after each error and picks middle lines for the query. Repetitive unknown text is folded
  by the log engine's templates.
• gain shows rerequest and wasted tokens per dialect, optimizer and command; raw prints a size header for
  large originals; learn names its top lesson at session start; per-family Claude token factors price the
  markers.
• Dashboard: costs and context pages with charts, one model table and a detail row per session; install -window
  sets Claude's auto-compact window; context reports what compactions cost and saved.

Changed

• max_image_pixels is 600000 (was 0, off): screenshots above it are downscaled by the proxy and the hook. Set
  it to 0 to keep images whole.
• history bypasses a source after 2 failures (3 for fetch URLs) inside failure_ttl (24h); before, one failure
  bypassed it for good.
• find and tree folds keep directory and package names; dense leaves delimited lists alone.
• Test runner rule tables moved to pcomb.

Fixed

• Usage and MCP calls are counted by local day; the day trend keeps today for periods that are not whole days.
• Chained commands are named by the work they do.
• Recorded eval runs stay out of the unpriced agents.

v0.7.2

Commands with quoted env assignments, like NODE_OPTIONS="--max-old-space-size=4096" npm run build, run through the hook again.

Fixed

• Hook rewrites keep quoted env assignments outside gascoigne exec, as in DATABASE_URL="postgres://app@localhost/app?sslmode=disable" go test ./... or NODE_OPTIONS="--max-old-space-size=4096" npm run build. They failed with "executable not found".
• A line the hook already rewrote is not wrapped a second time when it holds a quoted env value.
• command, exec and time lines stay unwrapped: they are shell builtins or keywords, there is no program for exec to run.

v0.7.1

The release notice checks for a newer version every 15 minutes, the dashboard gains a costs page, and make eval
prints a readable summary.

Added

• Dashboard: a costs page, readable long periods and session filters.
• make eval prints a banner per suite, savings bars and a final summary.

Changed

• The release notice reads latest.json every 15 minutes, from agent hooks and dashboard instead of the
  background server, and a prompt (not only a session start) opens the page of a newer release.

Fixed

• The release page is retried until it opens.
• eval.sh runs on the bash 3.2 shipped with macOS.
• The fake MCP authorize endpoint (tests) redirects only to loopback, to the fixed callback path.

v0.7.0

Many more tools are recognised and shortened (build, test and package managers, stack traces, source outlines for
dozens of languages), and gain prints a short report by default and keeps its history past a year.

Added

• gain -csv for -by views and -failures; failing sources show when they last failed as "2d ago"; the overview
  header prices the savings (worth ~$…) when a cost estimate exists.

• gain controls: -full, -show/-hide overview sections, -top (default 10 rows per table, 0 all), -sort,
  -min-tokens. Plain gain now prints the essentials (totals, last 7 days, agents, commands, failing-sources warning); -full prints every section. Tables are cut at 10 rows with a count of the rest.

• gain history survives events_ttl: runs pruned from the ledger are first added to daily totals (daily_stats,
  daily_step_stats), kept forever by default (ledger.rollup_ttl). Session and reason groupings only cover stored runs.

• Source outline for Ruby, Crystal, Elixir, Lua, Julia (end-closed blocks), Haskell, Elm, OCaml/F#, Nim (declarations
  with indented bodies) and Clojure, Lisp, Scheme, Racket (parenthesis balance); Perl, R, PowerShell, Groovy, Solidity,
  Move, Odin and Vue/Svelte/Astro use the brace outline. Shebangs identify scripts without a file name.

• Build output of CMake, Ninja, Meson, Bazel, clang-tidy/cppcheck, MSVC, dmd/ldc2/dub, sbt/scalac, Swift,
  Zig, Kotlin, GHC/cabal, Dart, rubocop, pylint, formatters and other linters is recognised and grouped
  like compiler output; any unknown tool printing file:line: error lines is handled as build/generic.
  Dialects can be declared as one detect.Row with their own command and content examples.

• Test output of ctest, GoogleTest, Catch2, sbt/ScalaTest, dub, PHPUnit/Pest, swift test, mix test, minitest,
  unittest, node:test/TAP, Playwright, Cypress, Karma, flutter/dart test and cabal/stack: passes are counted,
  failures and summaries kept, dependency frames dropped. cargo bench, llvm-cov, tarpaulin and miri use
  the cargo rules.

• Package manager output of Composer, Bundler/gem, mix, pub, SwiftPM, NuGet, conda/mamba, deno, Nix, Flatpak/snap
  and mvn dependency:*: progress and download lines dropped, installs folded into lists, failures kept.

• Text lockfiles (yarn.lock, go.sum, Gemfile.lock) shrink to name@version lists (data/lock). docker stats,
  nerdctl, crictl, lsblk, lsmod, w are recognised as tables; gh pr diff, glab mr diff, jj/hg git-style
  diffs and gh pr checks, glab listings use the git and forge engines.

• Compiler output: runs of C++ template instantiation notes (gcc "required from", clang "in instantiation of … requested
  here") and include chains keep their ends and count the middle; a linker's undefined reference lines become one list of symbols; gcc's "required from" lines count as
  notes, not errors.

• Stack traces: runs of runtime and framework frames (JVM/Scala/Kotlin, Python site-packages, Rust backtraces, Ruby
  gems, .NET, PHP vendor, gdb/lldb and sanitizer frames in libc/libstdc++, D runtime) fold into one count
  (trace.min_frames); the first frame under an exception line stays, and AddressSanitizer's shadow dump folds.

• Source outline knows D (.d, .di) and more C++ (.cxx, .hh, .hxx, .ipp, .tpp, .inl, .cppm,
  .ixx, .cu, .cuh) and Scala (.sc, .sbt) extensions; Rust is also recognised without a file name.

• make eval runs every suite (fixtures, ext, scale, live, ledger) with one summary; testdata/eval-scale adds generated
  outputs of 3k to 50k lines with max_ms ceilings, and 22 dialects that had no case now have one.

Changed

• gain prints the essentials by default (totals, last 7 days, agents, commands, failing sources); -full prints every
  section as before, and tables stop at 10 rows (-top 0 for all).
• New table daily_stats / daily_step_stats and setting ledger.rollup_ttl (default 0s: forever). Runs older than
  events_ttl (still a year) are rolled into daily totals instead of being lost; the tables are created on first start,
  nothing is migrated.

Fixed

• Source outline: Rust lifetimes (&'static str), nested block comments (Rust, Scala, D), C++ and Rust raw
  strings and digit separators no longer break brace counting; functions inside mod, union, package
  and extern "C" blocks are outlined.
• The release notice reads latest.json hourly instead of daily, so a release published the day after a
  read is no longer hidden for up to 24 hours.

v0.6.1

The dashboard tells optimizing apart from rerequesting: when the agent asks for the original after an
optimized result, the run is no longer counted as a saving.

Added

• Outcome rerequested: an optimized run the agent then fetched in full (gascoigne raw, MCP retrieve)
  or reran raw is stored as rerequested, not optimized. Runs recorded before are converted once, on the
  first start of the ledger.
• A rerequested run costs the agent the optimized result plus the original, so savings, gain and the
  cost section now subtract it.
• Dashboard: an "Optimizing vs rerequesting" chart (gross saved, given back, net, rerequest rate per day;
  GET /api/impact), and run feed filters Optimized, Bypassed, Unchanged, Rerequested, Raw (the agent
  asked for the original at once) and Failed. Bypassed has its own color.
• ledger.events_ttl: how long runs, API usage and failure history stay.

Changed

• Retention defaults: originals 30 days (was 24 hours), MCP tool stats one year (was two weeks), runs, API
  usage and failure history one year (were kept forever). 0 keeps any of them forever.

Fixed

• gascoigne tokens with no file and a terminal on stdin waited for input forever; it now says what to do.
• gascoigne tokens no longer stalls on long text without spaces (minified or base64 data): the o200k
  count was quadratic. Its downloads and the Claude count request time out after 30 seconds.
• Groups in gain were ordered by gross savings, ignoring the rerequest cost.
• git branch output with blank lines (several commands run together) crashed the git optimizer.

v0.6.0

A second prose model you can pick in setup, a progress bar for its download, and an API for agent
framework SDKs. The prose model stays an experiment.

Added

• A second prose model, ctxprune-small (563 MB, trained on tool output, logs, code and web text). Pick it
  with optimizers.prose.model or in gascoigne setup, which downloads the model you choose and checks
  its files; gascoigne prose install -name <model> fetches either. The ONNX Runtime is shared.
• A progress bar while prose install and setup download the model and the runtime, when stderr is a
  terminal.
• /sdk/v1 on the background server: the API the agent framework SDKs use.
• A minimal Alpine Dockerfile: a static build, a non-root user, the subcommand as the container command.
• The dashboard shows the live status on every page and records the MCP tool lists daily.

Changed

• The default prose model is the int8 weight-only graph: 274 MB instead of 601 MB, the same savings,
  identical output on CPU and CUDA.
• Models are named as on Hugging Face (kompress-v2-base, ctxprune-small) and each installs into a
  directory of its own name, so files and checksums never mix. Installs from 0.5.0 kept the model in the
  root: run gascoigne prose install once more.
• make eval-experimental names the model of each run, so your setup choice does not change its goldens.
• The dashboard's run details use plain labels (Command or tool, Steps tried, Skipped by, Original id), and
  the prose step explains in plain words what it did or why it skipped.
• Maven errors keep their symbol and location lines, and a repeated finding lists every line it occurs at.

Fixed

• Unpacking the ONNX Runtime archive cannot write outside its directory, whatever entry names or symlink
  targets the archive holds.

v0.5.0

Prose compression with a local model, and a dashboard that groups its tables. The model is an experiment:
off until you turn it on.

Added

• Experimental prose compression (experimental: [prose]): a ModernBERT extractive model drops low-value
  words from the plain paragraphs of text and markdown, including converted web pages. Numbers, paths,
  flags, identifiers, negations, code and links stay; tables and aligned output are left alone. It runs
  inside the process that optimizes, on CUDA (Linux, Windows), CoreML (macOS) or the CPU, with no cgo and no
  Python (ONNX Runtime is opened at run time), and the background server keeps it loaded. It has its own
  optimizer id prose, so its savings show apart in gain -by optimizer.
• gascoigne prose install downloads the model and ONNX Runtime for your platform, checks pinned SHA256
  hashes and prints them; gascoigne prose status says whether it is ready. gascoigne setup runs the
  download when you turn the experiment on and checks the files again later.
• optimizers.prose.idle frees the model and its GPU memory after five idle minutes; a damaged download
  fails with a clear error.
• Dashboard: an Experiments panel for the features that are on, a prose −N tag on runs the model
  shortened, a prose line in run details and the run's raw id.
• eval -record writes an eval run to your ledger and starts the dashboard; make eval-experimental
  uses it. A separate eval set, testdata/eval-experimental, covers the opt-in features.

Changed

• The dashboard's tables are tabs in two panels: models and cost (families, models, API requests) and
  breakdown (command, optimizer, content type, not optimized, excluded sources); the tab is remembered.
• eval ignores experimental settings, so its numbers do not depend on your choices.
• New dependencies: github.com/ebitengine/purego (loads ONNX Runtime without cgo) and golang.org/x/text
  (Unicode normalization for the tokenizer). Builds stay CGO_ENABLED=0.

Fixed

• The dashboard page tests never ran outside GOOS=js (the file name ended in _js).

v0.4.1

Fixed

• The release notice read latest.json from the website's old address (404 since the site moved to
  gascoigne-ai.github.io), so no update was ever signalled.

v0.4.0

Prebuilt binaries on every release.

Added

• Linux, macOS and Windows archives (amd64, arm64) with checksums.txt attached to each GitHub release,
  with install one-liners that verify the checksum (README, getting started, website).

Fixed

• The release workflow attaches the binaries to a release created in the web UI instead of failing
  because it already exists, and can be run by hand for an existing tag.
• Links with data: and vbscript: targets are dropped from fetched pages like javascript: ones;
  after/before in the dashboard events API are parsed without truncation.

v0.3.0

Setting up and keeping up to date. gascoigne asks, in a browser page or the terminal, before it changes how your agents are set up, gascoigne upgrade brings everything current after a new version, and gascoigne doctor says what is wrong in plain words. The dashboard shows savings by model and sorts and filters every table.
Added

A release notice: once a day the background server reads latest.json from the project website; when a newer release is out, the next session opens its page once. A plain request with nothing about you in it; off with GASCOIGNE_RELEASE_CHECK=off or in gascoigne setup.
install -guide off|short|full (or $GASCOIGNE_GUIDE): how much usage text agents get.
install -permissions none|local|all: allow rules for gascoigne's own tools in claude, removed exactly by unwrap.
gascoigne upgrade [-n]: after installing a new version, one command writes stale or lost hooks, rules and commands again, moves config.yaml onto the new template (settings kept) and opens the page for choices still waiting. install -autosync on does the user-level part by itself.
gascoigne setup and a /setup page in the dashboard: permissions and hook updates are asked once, in the browser (or the terminal), before anything is changed.
A coding agent found on PATH without a gascoigne install is signaled once (session note and the setup page) and installed only on a yes.
gascoigne doctor (a plain-language report), and /gascoigne-stats and /gascoigne-doctor commands in claude.
gain -oneline: totals on one line, for a status line.
Experimental continuity: after a compaction or resume, claude gets a short snapshot of its last request, open tasks, edited files and failed commands.
Experimental learn: propose instruction lines from habits that cost context (reruns of shortened output, large unshortened output).
Dashboard: every table, the recent runs included, sorts by clicking a header and has a filter box.
Dashboard: savings by model family and by model, in the model's own tokens and dollars, with the official list prices they are estimated from.

Changed

The setup page shows what gascoigne found (agents and their state), groups the questions, and says under each option what it does.

gascoigne setup -experimental (and the setup page, in a folded section) turn the experimental features on or off, each with an example, how it works and its impact.

gascoigne setup opens the page in the browser (-t asks in the terminal).

Installs from before this version are found from the agents' config files, so the first session after upgrading offers the hook update.

Documentation diagrams are Mermaid (README, architecture), with new flows for how a command is optimized and for upgrading.

Fixed

The usage guide no longer tells codex how to write commands for a rewrite hook it lacks, nor names MCP tools pi does not have.