token-goat 2.0.0 → 2.0.1

package/README.md

@@ -9,7 +9,7 @@ permalink: /
 
 ![Token-Goat](assets/logo.png)
 
-**85%** smaller reads · **97.4%** image compression · **130+** bash output filters · **94–99%** skill overhead cut · compaction memory · **prompt injection** guard
+**85%** smaller reads · **97.4%** image compression · **130+** bash output filters · **94–99%** skill overhead cut · compaction memory · **prompt injection** guard · **3.7 GB** never reached the model · **1.1 Gt** tokens saved
 
 **Reduces AI token use/costs by 40–90%, and improves its focus. Fully automated, always online.**
 
@@ -17,7 +17,7 @@ permalink: /
 
 **Your AI re-reads the same file three times. Every compaction causes amnesia. Every build log buries the one line that matters. You pay for all of it. Token-Goat fixes all of it — automatically.**
 
-Token-Goat sits silently between your AI and your tools. Re-read a file? It gets a one-line hint and a narrow-slice suggestion instead of the full file again. Grab a screenshot? A 100 KB copy reaches the model instead of 10 MB. Run `pytest`, `npm install`, `docker build`, or `cargo`? The thousands of progress bars and passing-test names are stripped to the failures before the output even reaches the context window. Compact a long session? It gets a clean structured manifest of edited files and key symbols so nothing important is forgotten. Sessions drop 40–90%+ in cost. You change nothing about how you work.
+Token-Goat sits silently between your AI and your tools. Re-read a file? It gets a one-line hint and a narrow-slice suggestion instead of the full file again. Grab a screenshot? A 100 KB copy reaches the model instead of 10 MB. Run `pytest`, `npm install`, `docker build`, or `cargo`? The thousands of progress bars and passing-test names are stripped to the failures before the output even reaches the context window. Open a PDF, a large Markdown doc, or a CSV? The hook intercepts it — heading tree, page count, or column preview — so the model never pays for the full file. Run `gh run watch` or `next dev` a second time? Prior output is recalled rather than re-run. Compact a long session? It gets a clean structured manifest of edited files and key symbols so nothing important is forgotten. Sessions drop 40–90%+ in cost. You change nothing about how you work.
 
 Works with **Claude Code**, **Gemini CLI**, **Codex CLI**, **Aider**, **Cursor**, **Cline**, **Windsurf**, **Copilot CLI**, OpenCode, OpenClaw, and **pi** ([pi-coding-agent](https://github.com/earendil-works/pi-mono)).
 
@@ -40,9 +40,9 @@ Restart your AI sessions. Run `token-goat stats` a couple of minutes after your
 ---
 
 <p align="center">
-  <img src="assets/stats_v180.png" alt="token-goat stats — v1.8.0" width="589">
+  <img src="assets/stats_v180.png" alt="token-goat stats display" width="589">
   <br>
-  <sub><b>v1.8.0</b> — with bash output compression and extended filter library</sub>
+  <sub>Stats display — gradient bars, sparklines, and a calendar heatmap in 24-bit color</sub>
 </p>
 
 ## The problem
@@ -74,6 +74,7 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | `rg pattern src/` or `grep -rn` run via Bash (first time) | Pre-Bash hook suggests `token-goat symbol <name>` and `token-goat semantic "<query>"` as indexed alternatives to a full directory walk |
 | `rg` or `grep` run twice with the same pattern | Pre-Bash dedup hint fires on repeated `rg`/`grep`/`ag` calls the same way it fires on the native Grep tool; repeat searches return a cached match-count hint instead of re-running |
 | Read tool targets `tool-results/<id>.txt` or `tasks/<id>.output` | Pre-Read hook suggests `token-goat bash-output <id> --tail N` / `--grep PATTERN` / `--section H`; the filename stem is the output ID |
+| Repeated monitoring command run again (`gh run watch`, `next dev`, `vitest`, `docker logs`) | Pre-bash recall hint: when a prior run is cached and its output exceeds 2 KB, a pointer to `token-goat bash-output <id> --grep PATTERN` is injected instead of re-running the command |
 | `pnpm`/`yarn`/`bun` install or build dumps full output | pnpm, yarn, and bun compress filters now strip install noise and build logs the same way npm does; `pnpm run`/`yarn run` route through their own filter |
 | Surgical-read command returns a 10k-line symbol or a full section dump | Capped at ~25k tokens; marker names the truncation ratio and narrowing command (`symbol` → `file::Class.method`; `section` → sub-heading; cached → `--grep`/`--tail`) |
 | Full file read for one function or section | `token-goat read file::symbol`, about 85% smaller |
@@ -94,6 +95,10 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Manifest too large or unstructured after compaction | Manifest gains `### MUST_PRESERVE` sealed block, `### What Worked` (last 2 green test runs), inline git diffs, and `### TODOs` from TaskList |
 | CSV/JSON/JSONL/log file re-read when only structure changed | Pre-Read hint for structured files (CSV headers, JSON keys, log format), ~70% smaller than full read |
 | Index-only files (lockfiles, source maps, bundles) read on every session | Pre-Read suppression for read-only files (package-lock.json, *.map, dist/), skipped unless explicitly edited |
+| Large markdown file read in full (README.md, CHANGELOG.md, CLAUDE.md ≥8 KB) | Heading tree intercepted instead — H1–H3 with `#2`/`#3` disambiguation; `token-goat section` shortcuts listed for well-known files; post-edit injects a re-read suggestion rather than the full file |
+| PDF or Office binary (.docx, .xlsx, .pptx, .odt) opened via Read | Full read denied; PDF shows page count and outline; Office binaries redirect to `pandoc` or `docx2txt` for text extraction |
+| Large CSV or TSV file (≥10 KB) read in full | Column headers, row count, and 3 sample rows shown; `duckdb` query suggestion for large tabular data |
+| Large TXT or log file (≥20 KB) read in full | Line count + first/last 5 lines shown; `.log`/`.out` files bias toward `--tail 100 --grep`; general catch-all for any file ≥100 KB |
 | Subagent reads a 47–86 KB recon dump (or greps a 73 KB transcript) and overflows its window | `pre_read` denies a full Read at or above `large_read_redirect_bytes` (~45 KB default), and a `content`-mode Grep over one oversized file, redirecting both to surgical reads or a windowed `offset`/`limit` |
 | Subagent overflows at "hello" with no idea why | `token-goat baseline` attributes the fixed environmental floor — other plugins' hook dumps, both CLAUDE.md files, MEMORY.md, MCP servers — by owner, suggested fix, and fixed-vs-variable cost |
 | MCP screenshot call lands 10 MB image in context because no file path was passed | `pre_screenshot` denies chrome-devtools and playwright screenshot calls without a `filePath`/`file_path` argument; redirects the model to re-issue with one, so the saved file flows through image-shrink (~39K tokens raw → ~8K compressed) |
@@ -117,7 +122,7 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Skill body lost after compaction but recovery too verbose | Recovery hint deduped skills by content_sha (same skill loaded twice = one entry); inline skill checklist |
 | Recovery hints omit critical paths when space is tight | Hint budget hard caps per kind (files=5, bash=3, web=2, skills=4); skip bash snippet when recall available |
 | `token-goat map` outputs without rank context | Semantic compact mode outputs one result per line; `--full` for old format |
-| AVIF format not supported despite better compression | AVIF image-shrink (when Pillow has libaom); WebP fallback; codec auto-detection in docker |
+| AVIF format not supported despite better compression | AVIF image-shrink via sharp (when libvips is built with libaom); WebP fallback; codec auto-detection in docker |
 | Token-savings invisible until you run `stats` | Token-savings benchmark (slow-marked test suite) locks in measured wins; `token-goat stats` reports net-positive impact |
 | Hook crash leaves agent waiting for response | Fail-soft barrier catches `BaseException`/`MemoryError`/`SystemExit`; hook always returns `{"continue": true}` |
 | Concurrent edits lose update counts mid-session | Session CAS + mtime-based retry prevent lost edits in manifest |
@@ -127,8 +132,6 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Compaction hook subprocess ~190 ms cold | Lazy imports of heavy modules in `hooks_session` and `compact`; compaction path ~110 ms cold (~42% faster) |
 | Pre-compact subprocess runs on every session | Compact-skip sentinel on disk: if session file is <5 min old and no edits logged, subprocess exits in <1 ms |
 | Git ops slow manifest build in non-repo dirs | `git diff` / `git log` calls skipped when `cwd` is not inside a git repo (saves 60–100 ms per hook fire) |
-| Test suite slow on multi-core machines | `pytest-xdist --dist=loadscope` + module-scoped fixtures for read-only groups; parallel workers cut wall time |
-| Flaky tests fail the whole run | `pytest-rerunfailures` auto-retries once before failing; `pytest-randomly` seeds expose order-dependent flakes |
 | `terraform init` downloads 30+ provider plugins | Provider install lines collapsed to a count note; generic progress lines head/tail compressed (5+5 kept); `Init complete!` preserved |
 | `terraform show` dumps a full resource block | Noise attributes (id, arn, timeouts, tags) stripped per resource block; high-signal fields kept with a suppression note |
 | `kubectl events` lists raw repetitive events | Events grouped by REASON with a per-group count; field-selector hint added to narrow scope |
@@ -146,15 +149,15 @@ Numbers below come from synthetic-fixture benchmarks in the test suite. Each row
 
 | Source | Improvement | Measured impact | Where |
 |--------|-------------|-----------------|-------|
-| Image shrink | WebP encoder beats JPEG on screenshot-shaped images | ~39% smaller than the same image at JPEG quality 85 | `image_shrink.py` (codec selection) |
-| Repomap output | Short labels (`f:`, `s:`, `c:`) and auto-compact mode below 6 KB | ~30–40% denser output for the same byte budget | `repomap.py` (`token-goat map --budget`) |
-| DB reindex | Batched single transaction + composite indexes on `(file_id, kind)` | 100 files / 10K rows: 84 s → 1 s (~80× faster) | `parser.py`, `db.py` (index migration) |
-| Hook cold-start | Lazy import of heavy modules; unknown events short-circuit | 86 ms → 30 ms (~65% faster); unknown-event dispatch <1 ms | `hooks_cli.py` |
-| Symbol start_line | TypeScript decorators captured in symbol span | One `token-goat read` returns the decorator + signature + body; no re-read | `languages/typescript.py` |
-| Section extraction | Setext headings, h5/h6, anchor IDs, and `__frontmatter__` | `token-goat section` resolves more headings without falling back to a full file read | `languages/markdown.py` |
-| Image cache | Real LRU eviction (was FIFO; old hot entries got dropped) | Higher hit rate on repeat screenshots in long sessions | `image_shrink.py` |
-| Monorepo defaults | Reindex batch 500 → 2000; compact `min_events` 5 → 3 | Fewer worker wakeups; compact manifests fire on shorter sessions | `config.py` defaults |
-| Miss suggestions | `symbol` auto-redirects on a single high-confidence close match (`--strict` opts out); `read` / `section` print "Did you mean…?" | Keeps agents on the surgical-read path instead of falling back to full-file `Read` | `read_replacement.py` |
+| Image shrink | WebP encoder beats JPEG on screenshot-shaped images | ~39% smaller than the same image at JPEG quality 85 | `src/image_shrink.ts` (codec selection) |
+| Repomap output | Short labels (`f:`, `s:`, `c:`) and auto-compact mode below 6 KB | ~30–40% denser output for the same byte budget | `src/repomap.ts` (`token-goat map --budget`) |
+| DB reindex | Batched single transaction + composite indexes on `(file_id, kind)` | 100 files / 10K rows: 84 s → 1 s (~80× faster) | `src/parser.ts`, `src/db.ts` (index migration) |
+| Hook cold-start | Lazy import of heavy modules; unknown events short-circuit | 86 ms → 30 ms (~65% faster); unknown-event dispatch <1 ms | `src/hooks_cli.ts` |
+| Symbol start_line | TypeScript decorators captured in symbol span | One `token-goat read` returns the decorator + signature + body; no re-read | `src/parser.ts` (TypeScript adapter) |
+| Section extraction | Setext headings, h5/h6, anchor IDs, and `__frontmatter__` | `token-goat section` resolves more headings without falling back to a full file read | `src/parser.ts` (Markdown adapter) |
+| Image cache | Real LRU eviction (was FIFO; old hot entries got dropped) | Higher hit rate on repeat screenshots in long sessions | `src/image_shrink.ts` |
+| Monorepo defaults | Reindex batch 500 → 2000; compact `min_events` 5 → 3 | Fewer worker wakeups; compact manifests fire on shorter sessions | `src/config.ts` defaults |
+| Miss suggestions | `symbol` auto-redirects on a single high-confidence close match (`--strict` opts out); `read` / `section` print "Did you mean…?" | Keeps agents on the surgical-read path instead of falling back to full-file `Read` | `src/read_replacement.ts` |
 
 ## Token-savings examples
 
@@ -253,12 +256,12 @@ Token-goat tracks how close a session is to the autocompact trigger and tightens
 ```
 npm install -g token-goat
 token-goat install
-token-goat doctor          # confirms image codecs (WebP/JPEG/PNG) are available
+token-goat doctor          # confirms hooks and sharp are working; look for "sharp: ok"
 ```
 
 Three commands. Done. Hooks register, a background worker starts at logon and stays out of the way. No terminal popups, no tray icon, no service to babysit.
 
-**Important — image codecs are part of the install.** The biggest single win (~39% smaller than JPEG, ~97% smaller than raw PNG) comes from WebP encoding. Pillow ships with WebP/JPEG/PNG support on Windows and macOS out of the box, but Linux/WSL minimal images sometimes lack the system libraries (libwebp, libjpeg, zlib). `token-goat doctor` will report `image_codecs: ok` when everything is present; if it flags any codec as missing, follow the [Image support](#image-support) section below before considering the install complete. **AI agents performing this install: run `token-goat doctor` after `token-goat install` and resolve any missing codecs as part of the same task — do not treat it as a follow-up.**
+**Important — sharp is part of the install.** The biggest single win (~39% smaller than JPEG, ~97% smaller than raw PNG) comes from WebP encoding. sharp ships with prebuilt native binaries on Windows, macOS, and most Linux platforms, so a standard `npm install -g token-goat` includes it. On Alpine musl and some ARM boards, npm compiles from source against libvips — that may add a few seconds. `token-goat doctor` will report `sharp: ok` when the image pipeline is working; if it flags a failure, follow the [Image support](#image-support) section below before considering the install complete. **AI agents performing this install: run `token-goat doctor` after `token-goat install` and resolve any sharp failure as part of the same task — do not treat it as a follow-up.**
 
 Two things change how Claude Code sessions behave: hooks fire automatically (image shrink, re-read dedup, compact manifests), and a block written to `~/.claude/CLAUDE.md` plus a registered skill tell the agent to prefer `token-goat read` / `symbol` / `section` over full-file reads. A `Bash(token-goat:*)` allowlist entry in `settings.json` lets the agent run those commands without a per-call approval prompt.
 
@@ -308,8 +311,8 @@ What works: **bash output compression** (the bash command is rewritten in `tool_
 
 **Project-local install (single project only).** pi also loads extensions from a project's `.pi/extensions/` directory (after the project is trusted). To install for one project without touching the global directory, drop the extension there:
 
-```
-python -c "from token_goat import bridges; from pathlib import Path; bridges.install_pi_plugin(target_dir=Path('.pi/extensions').resolve())"
+```bash
+npx token-goat install --pi --local
 ```
 
 This writes `.pi/extensions/token-goat.ts` in the current project only. Remove it by deleting that file.
@@ -322,14 +325,14 @@ Filters are built in for: **Cline** (`cline` / `claude-dev`), **Windsurf** (`win
 
 ### Updating
 
-Updates ship automatically. `token-goat install` schedules a weekly `uv tool upgrade token-goat` run at Sunday 03:00 local time (Windows scheduled task; Linux/macOS crontab line tagged `# token-goat-autoupdate`). `token-goat uninstall` reverses it.
+Updates ship automatically. `token-goat install` schedules a weekly `npm install -g token-goat@latest` run at Sunday 03:00 local time (Windows scheduled task; Linux/macOS crontab line tagged `# token-goat-autoupdate`). `token-goat uninstall` reverses it.
 
 Manual paths:
 
 | When | Command |
 |------|---------|
-| Update now | `uv tool upgrade token-goat` |
-| Reinstall from scratch (broken venv, missing image codec) | `uv tool install --reinstall --force token-goat` |
+| Update now | `npm install -g token-goat@latest` |
+| Reinstall from scratch (broken install, sharp failure) | `npm install -g token-goat@latest` |
 | Disable auto-updates | Delete the `token-goat-update` scheduled task (Windows) or the `# token-goat-autoupdate` crontab line (Linux/macOS) |
 
 ## CLI
@@ -447,9 +450,9 @@ To check overhead for your current skills: `token-goat skill-size`. To inspect c
 | Linux (no systemd, incl. WSL) | `~/.config/autostart/token-goat-worker.desktop`. On WSL without systemd, the SessionStart hook also starts the worker on every Claude Code session. |
 | macOS (untested) | `~/Library/LaunchAgents/com.dfkhelper.token-goat-worker.plist`, loaded via `launchctl`. |
 
-The autostart command is `pythonw -m token_goat.cli worker --daemon` from Token-Goat's `uv tool` venv. No PyInstaller-style launcher `.exe` is dropped; AV/EDR products do not behavior-flag this invocation pattern.
+The autostart command is `node <npm-prefix>/lib/node_modules/token-goat/dist/cli.js worker --daemon`. No compiled `.exe` is dropped; AV/EDR products do not behavior-flag this invocation pattern.
 
-**Weekly auto-update** (Sunday 03:00 local time, runs `uv tool upgrade token-goat`)
+**Weekly auto-update** (Sunday 03:00 local time, runs `npm install -g token-goat@latest`)
 
 | Platform | Entry |
 |---------|------|
@@ -513,7 +516,9 @@ token-goat stats
 
 ## Image support
 
-The image-shrink pipeline relies on Pillow with WebP, JPEG, and PNG codecs. Pillow ships as a binary wheel on every platform `uv` supports, so a normal `uv tool install token-goat` puts all three codecs in place without extra steps. The instructions below are only needed if `token-goat doctor` reports `Pillow codecs: WebP=MISSING` (or similar) — that flag means Pillow was built from source against a system that did not ship the codec libraries.
+Token-goat shrinks large images before they reach the model, cutting vision token costs by 60–90%. The pipeline uses [`sharp`](https://sharp.pixelplumbing.com/), a Node.js image processing library that ships prebuilt native binaries for Windows, macOS, Linux, and Alpine.
+
+On most platforms, `npm install -g token-goat` installs sharp without additional steps. npm pulls a prebuilt binary keyed to your Node.js major version and OS — no C++ compiler, libvips, or system codec libraries required.
 
 Quick check (any platform):
 
@@ -521,117 +526,39 @@ Quick check (any platform):
 token-goat doctor
 ```
 
-If the `Pillow codecs` line reports any `MISSING` or `FAIL`, follow the platform section below.
-
-### Image support — Windows
-
-The official Pillow wheel for Windows bundles libwebp, libjpeg-turbo, and libpng. A failing codec almost always means Pillow was reinstalled inside a stripped-down environment. Reinstall token-goat (and its bundled Pillow wheel) end-to-end:
+If the `sharp` line shows `OK`, you're done.
 
-```powershell
-uv tool install --reinstall --force token-goat
-token-goat doctor
-```
+### Image support — troubleshooting
 
-### Image support — macOS
-
-Same story as Windows — the universal wheel ships every codec. Reinstall to get the wheel back:
+If `token-goat doctor` reports `sharp: FAIL`, the most common cause is a cached binary built against a different Node.js version. A fresh install usually fixes it:
 
 ```bash
-uv tool install --reinstall --force token-goat
+npm install -g token-goat@latest
 token-goat doctor
 ```
 
-If you previously installed Pillow via Homebrew with `--build-from-source`, install the libraries first, then reinstall:
-
-```bash
-brew install webp jpeg-turbo libpng
-uv tool install --reinstall --force token-goat
-```
-
-### Image support — Linux / WSL
-
-Almost every Linux distro pulls the manylinux Pillow wheel, which bundles every codec. The exceptions are: musl-based distros (Alpine), some ARM boards lacking a matching wheel, and environments where the user forced `--no-binary :all:`. In those cases, install the system headers, then reinstall:
+On Alpine Linux, some ARM boards, and air-gapped environments, npm can't fetch a prebuilt binary and falls back to compiling from source. That requires `libvips` and C++ build tools:
 
 ```bash
 # Debian / Ubuntu / WSL
-sudo apt-get update
-sudo apt-get install -y libwebp-dev libjpeg-turbo8-dev libpng-dev
-uv tool install --reinstall --force token-goat
-token-goat doctor
-```
-
-```bash
-# Fedora / RHEL / Alma
-sudo dnf install -y libwebp-devel libjpeg-turbo-devel libpng-devel
-uv tool install --reinstall --force token-goat
-```
+sudo apt-get install -y libvips-dev build-essential
 
-```bash
-# Arch / Manjaro
-sudo pacman -S --noconfirm libwebp libjpeg-turbo libpng
-uv tool install --reinstall --force token-goat
-```
-
-```bash
 # Alpine
-sudo apk add libwebp-dev libjpeg-turbo-dev libpng-dev
-uv tool install --reinstall --force token-goat
-```
+apk add --no-cache vips-dev build-base python3
 
-### Image support — AI automated setup
-
-Non-interactive snippets agents can run unattended. Each one is idempotent: it checks current state before changing anything, and re-runs `token-goat doctor` at the end so the agent can verify success from the output.
-
-#### Windows (PowerShell)
-
-```powershell
-# 1. Verify token-goat is reachable; reinstall if not
-if (-not (Get-Command token-goat -ErrorAction SilentlyContinue)) {
-    uv tool install token-goat
-}
-
-# 2. If doctor flags any image codec, reinstall the bundled Pillow wheel
-$doctor = token-goat doctor 2>&1 | Out-String
-if ($doctor -match 'Pillow codecs:.*(MISSING|FAIL)') {
-    uv tool install --reinstall --force token-goat
-}
-
-# 3. Verify
-token-goat doctor
+# Fedora / RHEL
+sudo dnf install -y vips-devel gcc-c++ make
 ```
 
-#### macOS / Linux / WSL (bash)
+After installing the system packages:
 
 ```bash
-set -e
-
-# 1. Verify token-goat is reachable; reinstall if not
-command -v token-goat >/dev/null 2>&1 || uv tool install token-goat
-
-# 2. If doctor flags any image codec, install platform packages then reinstall
-need_fix=$(token-goat doctor 2>&1 | grep -E 'Pillow codecs:.*(MISSING|FAIL)' || true)
-if [[ -n "$need_fix" ]]; then
-    OS="$(uname -s)"
-    if [[ "$OS" == "Darwin" ]]; then
-        command -v brew >/dev/null 2>&1 && brew install webp jpeg-turbo libpng
-    elif [[ "$OS" == "Linux" ]]; then
-        if   command -v apt-get >/dev/null 2>&1; then
-            sudo apt-get update && sudo apt-get install -y libwebp-dev libjpeg-turbo8-dev libpng-dev
-        elif command -v dnf     >/dev/null 2>&1; then
-            sudo dnf install -y libwebp-devel libjpeg-turbo-devel libpng-devel
-        elif command -v pacman  >/dev/null 2>&1; then
-            sudo pacman -S --noconfirm libwebp libjpeg-turbo libpng
-        elif command -v apk     >/dev/null 2>&1; then
-            sudo apk add libwebp-dev libjpeg-turbo-dev libpng-dev
-        fi
-    fi
-    uv tool install --reinstall --force token-goat
-fi
-
-# 3. Verify
+npm install -g token-goat@latest
 token-goat doctor
 ```
 
+For platform-specific build details, see the [sharp installation docs](https://sharp.pixelplumbing.com/install).
+
 ## Stats display
 
 `token-goat stats` uses 24-bit ANSI color and Unicode block characters for gradient bars, sparklines, and the activity heatmap. In the right terminal it renders sharply. In the wrong one you get broken characters, flat gray blocks, or a "rich is not installed" error.
@@ -758,12 +685,7 @@ token-goat stats
 Run this if the stats output still looks wrong. A smooth green gradient from left to right means truecolor is active. Solid single-shade green means it isn't.
 
 ```bash
-python3 -c "
-import sys
-for r in range(0, 256, 32):
-    sys.stdout.write(f'\x1b[48;2;0;{r};0m  ')
-sys.stdout.write('\x1b[0m\n')
-"
+node -e "for(let r=0;r<256;r+=32)process.stdout.write('\x1b[48;2;0;'+r+';0m  ');process.stdout.write('\x1b[0m\n')"
 ```
 
 ## Security, privacy, and uninstall
@@ -804,7 +726,7 @@ Reverses everything in [What gets installed?](#what-gets-installed): the schedul
 
 I built this because long Claude Code and Codex sessions on my machine kept burning context in the same ways: screenshots landing at 2-3 MB, the agent re-reading a file it parsed hours earlier in the same conversation, compactions that forgot which functions were edited. Each felt preventable.
 
-This is a solo project. I use it daily on Windows 11. Tests run across Python 3.12 and 3.13.
+This is a solo project. I use it daily on Windows 11. Tests run on Node.js 20 and 22.
 
 ## Requests and issues