token-goat 2.9.26 → 2.9.29

package/README.md

@@ -43,17 +43,9 @@ Restart your AI sessions. Run `token-goat stats` a couple of minutes after your
 
 ---
 
-<p align="center">
-  <img src="assets/token-goat-comparison.jpg" alt="Side-by-side comparison: a bloated workflow sends whole files and grows context every round, while token-goat sends only the needed lines and stays lean" width="900">
-  <br>
-  <sub>Same requirements, smarter input: fewer input tokens, shorter answers, and context that stops compounding across rounds</sub>
-</p>
-
-<p align="center">
-  <img src="assets/stats_v180.png" alt="token-goat stats display" width="589">
-  <br>
-  <sub>Stats display — gradient bars, sparklines, and a calendar heatmap in 24-bit color</sub>
-</p>
+<p align="center"> <img src="assets/token-goat-comparison.jpg" alt="Side-by-side comparison: a bloated workflow sends whole files and grows context every round, while token-goat sends only the needed lines and stays lean" width="900"> <br> <sub>Same requirements, smarter input: fewer input tokens, shorter answers, and context that stops compounding across rounds</sub> </p>
+
+<p align="center"> <img src="assets/stats_v180.png" alt="token-goat stats display" width="589"> <br> <sub>Stats display — gradient bars, sparklines, and a calendar heatmap in 24-bit color</sub> </p>
 
 ## The problem
 
@@ -123,6 +115,8 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | SQLite database (.db, .sqlite, .sqlite3, .db3) opened via Read | Full read denied; redirects to the SQLite narrow-slice family (`sqlite-tables`/`sqlite-schema`/`sqlite-query`) instead of reading binary bytes into context |
 | Parquet file (.parquet) opened via Read | Full read denied; redirects to DuckDB for SQL querying instead of reading binary columnar data |
 | Large JSON or YAML file (≥20 KB) read in full | Top-level keys or array summary previewed; redirects to `json-outline`/`json-query` or `yaml-outline`/`yaml-query` instead of blowing context on multi-megabyte payloads |
+| A file read through inline Python, Node or PowerShell (`python -c "...open('r.json')..."`) | Runs capped at 2,000 tokens with no other filtering, so a one-key projection comes back whole; a whole-file dump is cut, ends with a recall id, and names `json-outline`/`json-query` for JSON and YAML. Still refused where the wrapper cannot run: a pipeline or chain, a background `&`, compression turned off |
+| Findings you want to survive a compaction | `token-goat note set <key> "<finding>"` stores one per project; notes print at every session start and in the compaction manifest |
 | Large JSON Lines file (.jsonl ≥20 KB) read in full | Record count and first-record schema shown; suggests slicing records with offset/limit instead of loading millions of tokens |
 | Other Office binary (.odt, .ods, .ott, .odp) opened via Read | Full read denied; redirects to `pandoc` for text extraction (no dedicated reader for these formats yet) |
 | Large CSV or TSV file (≥10 KB) read in full | Column headers, row count, and 3 sample rows shown; `token-goat csv-query` projects columns and/or filters rows instead of a full read; `duckdb` query suggestion for very large tabular data |
@@ -142,7 +136,7 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Browser-automation MCP tool result (claude-in-chrome's `read_console_messages`/`read_network_requests`, chrome-devtools-mcp's `list_console_messages`/`list_network_requests`) carries verbose CDP plumbing per entry | Browser compression pack strips console `stackTrace` frames and network `requestHeaders`/`responseHeaders`/`timing`/`initiator`/`securityDetails`/cookie fields, keeping `url`/`method`/`status`/`resourceType`/`mimeType`/`reqid` and the actual log text, before the same table-ifying pass runs — same opt-out and full-recovery-by-id guarantee |
 | Atlassian MCP tool result (Jira issues, Confluence pages, search results) carries repetitive UI chrome and schemas | Atlassian compression pack strips boilerplate fields (`avatarUrls`, `iconUrl`, `self`, `expand`, `schema`, `operations`, `editmeta`, `names`, `_links`, `timeZone`), reducing payloads by 60–80% before table compression |
 | Oversized MCP tool result (≥25 KB) or dumped JSON tool spill file (e.g. `content.json`) re-read whole into context | Oversized MCP results return an elision preview and recovery ID; pre-read hooks intercept tool spill files, redirecting models to `token-goat mcp-output --json-query '<path>'` or `--file <path>` (~90–98% smaller) |
-| Large XML package (.dtsx, .ampkg, .xaml) read in full or paged with sequential line ranges | Pre-read hook intercepts package reads (20KB threshold) with package-specific hierarchy advice; sequential 3+ range paging is actively denied and redirected to `xml-outline` and `xml-query` |
+| Large XML package (.dtsx, .ampkg, .xaml) read in full or paged with sequential line ranges | Pre-read hook intercepts package reads (20KB threshold) with package-specific hierarchy advice; a fourth sequential range is denied once and redirected to `xml-outline` and `xml-query` |
 | Scratch terminal script or shell command used to inspect XML (`Select-Xml`, `[xml]`, `inspect_*.ps1`, Python `xml.etree`, `xmllint`) | Pre-bash hook intercepts terminal XML parsing commands, recommending `token-goat xml-query --xpath <expr>` or `xml-outline` instead of multi-step script generation (~85–95% smaller) |
 | XML document with deep element hierarchies or entity-encoded XML/AML payloads | `token-goat xml-query <file> --xpath <expr>` extracts targeted elements with exact line ranges (`--with-lines`), and `--decode-embedded-xml` pretty-prints and bounds nested AML payloads (~80–95% smaller) |
 | `curl -v` dumps TLS handshake + all request/response headers | Verbose lines stripped; request line, HTTP status, content-type, and body kept — typically 70–90% smaller |
@@ -184,6 +178,7 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Broad recursive Glob sweep (`*`, `**/*`) on root directory | Pre-Glob hook warns against tree-dumping and points at `token-goat map --compact` for fast, lightweight structure inspection |
 | Guessing database column names in `session_store_sql` / `sql` and falling back to `SELECT *` | `token-goat session-schema [table]` and `describe <target>` provide instant schema discovery; `post_tool_use_failure` hook intercepts unknown columns and guides the query — ~85–95% smaller than trial-and-error `SELECT *` dumps |
 | Compound test/build pipeline (`npm run build && npm run typecheck && npm test`) | Post-Bash hook routes chained build/test/lint commands to `generic-ci` compression, dropping verbose passing steps and compiler noise |
+| Verbose command output on Windows under Codex CLI, Copilot CLI, or a PowerShell session, where the compression hook used to skip every command | Pre-Bash hook hands the command to PowerShell itself, base64-encoded through an environment variable the launched script clears first, so backslashes, quotes, and redirection survive and the output is compressed like anywhere else |
 
 On a per-token API plan, 100K wasted tokens per session runs about $0.30. Five sessions a week is ~$450/year. AI coding cost reduction at that scale comes from fixing the waste, not from using the product less. Token-goat is free. And on subscription plans, it can result in limits feeling 10x higher.
 
@@ -196,9 +191,10 @@ cd ~/notes                  # or any plain folder of .md files, no .git required
 token-goat index . --walk   # non-git folders need --walk (git repos: plain `token-goat index .`)
 token-goat semantic --preflight   # verify runtime, model weights & project coverage
 token-goat semantic "how long to steep cold brew"
+token-goat semantic "how long to steep cold brew" "best grind for a pour-over"   # several queries in one call
 ```
 
-Returns relevance-ranked, distance-scored hits straight from the notes, the same surgical-read path used for code.
+Returns relevance-ranked, distance-scored hits straight from the notes, the same surgical-read path used for code. When the closest hit is a weak match (too far from the query to trust), a notice names the distance, so a weak hit is not mistaken for an answer.
 
 ## Token savings, measured
 
@@ -341,6 +337,8 @@ token-goat doctor          # confirms hooks are wired; reports any failure it fi
 
 Three commands. Hooks register and start working immediately: no terminal popups, no tray icon, no service to babysit. That wires up Claude Code; other agent CLIs are added with a flag (`--codex`, `--copilot`, and siblings).
 
+> **WSL performance tip:** Keep active repositories on WSL's native ext4 filesystem (`~/projects/...`) rather than Windows mounts (`/mnt/c/...`) to avoid 9P cross-OS filesystem translation overhead during initial indexing.
+
 Per-harness setup for Codex, Gemini, Qwen, Kimi, opencode, OpenClaw, pi, Copilot, Grok and Cline/Windsurf/Cursor, the companion CLI tools worth installing alongside it, upgrading, and the full list of what lands on your machine: **[Install guide](docs/install.md)**.
 
 ## CLI
@@ -387,64 +385,17 @@ token-goat handoff-resolve review-notes --full
 }
 ```
 
-`token-goat install --vscode` creates or idempotently updates VS Code's
-user-profile `mcp.json` by default (`%APPDATA%\Code\User\mcp.json` on
-Windows, `~/Library/Application Support/Code/User/mcp.json` on macOS,
-`~/.config/Code/User/mcp.json` on Linux) — add `-p`/`--project` for the
-project-local `.vscode/mcp.json` shown above instead. It also adds a delimited
-routing block, preserving unrelated JSON and user text: to
-`~/.copilot/instructions/token-goat.instructions.md` for the user install (a
-personal instructions file VS Code applies in every workspace, so the folder
-you run it from is left alone), or to `.github/copilot-instructions.md` with
-`-p`. It fails clearly on malformed JSON, and refuses to
-install into one scope if the other scope already has a token-goat-managed
-entry (registering it twice would duplicate its tool schemas in that
-workspace). It also installs agent hooks in `~/.copilot/hooks/` (or
-`.github/hooks/` with `-p`), the folder VS Code's Copilot agent reads hooks
-from, so token-goat sees the agent's built-in reads, edits, and terminal
-commands. `token-goat uninstall --vscode` (add `-p`/`--project` for the
-project scope) removes only token-goat's server entry, guidance block, and
-hooks, and keeps the hooks if `--copilot` still uses them.
-
-**Visual Studio** (2022 17.14 or later, or 2026): `token-goat install --visualstudio`
-adds the same `servers` entry to `%USERPROFILE%\.mcp.json` and a routing block
-to `%USERPROFILE%\copilot-instructions.md` (Visual Studio 2026 reads that
-file). With `-p`/`--project` it writes `.mcp.json` and
-`.github/copilot-instructions.md` in the solution folder instead. Visual Studio
-has no agent hooks, so token-goat works there through its MCP tools and
-instructions only: no read dedup, hints, image shrink, or output folding. Two
-switches in Visual Studio turn it on: the Tools > Options checkbox for custom
-instructions, and the token-goat tools in the chat Tools picker, since new MCP
-tools start disabled. `token-goat uninstall --visualstudio` (add `-p` for the
-project) removes only token-goat's entry and block. See
-[Visual Studio users](docs/install.md#visual-studio-users).
-
-**Zed**: `token-goat install --zed` registers token-goat as an MCP context
-server in Zed's `settings.json` (user scope only — Zed has no
-project-local equivalent). Zed's first-party agent has no hooks API at all,
-so this is MCP tools only, the same limits as Visual Studio above: no read
-dedup, hints, image shrink, or output folding. Enable the token-goat server
-under Zed's Agent panel tools list after installing; new MCP servers start
-disabled. `token-goat uninstall --zed` removes the entry and its generated
-shim script. See [Zed users](docs/install.md#zed-users).
-
-**Cursor**: `token-goat install --cursor` registers token-goat as an MCP
-server in `~/.cursor/mcp.json` (`-p`/`--project` for
-`<project>/.cursor/mcp.json`). This never touches `~/.cursor/hooks.json`:
-Cursor already imports Claude Code's hooks from `~/.claude/settings.json` by
-default, so a plain `token-goat install` for Claude Code already gets hooks
-running in Cursor too, with no separate Cursor hooks file to maintain or risk
-clobbering. `token-goat uninstall --cursor` removes only the MCP entry. See
-[Cursor users](docs/install.md#cursor-users).
-
-**JetBrains** (WebStorm, IntelliJ, PyCharm, Rider, PhpStorm): no integration
-today — no hooks, no MCP, no terminal filter. See
-[JetBrains IDEs users](docs/install.md#jetbrains-ides-webstorm-intellij-pycharm-rider-phpstorm-users)
-for why and what a Copilot-for-JetBrains user might already get for free.
-
-The optional source-controlled extension lives in `vscode-extension/`. Build
-and install its VSIX manually; `--vscode` intentionally does not copy or
-install extensions:
+`token-goat install --vscode` creates or idempotently updates VS Code's user-profile `mcp.json` by default (`%APPDATA%\Code\User\mcp.json` on Windows, `~/Library/Application Support/Code/User/mcp.json` on macOS, `~/.config/Code/User/mcp.json` on Linux) — add `-p`/`--project` for the project-local `.vscode/mcp.json` shown above instead. It also adds a delimited routing block, preserving unrelated JSON and user text: to `~/.copilot/instructions/token-goat.instructions.md` for the user install (a personal instructions file VS Code applies in every workspace, so the folder you run it from is left alone), or to `.github/copilot-instructions.md` with `-p`. It fails clearly on malformed JSON, and refuses to install into one scope if the other scope already has a token-goat-managed entry (registering it twice would duplicate its tool schemas in that workspace). It also installs agent hooks in `~/.copilot/hooks/` (or `.github/hooks/` with `-p`), the folder VS Code's Copilot agent reads hooks from, so token-goat sees the agent's built-in reads, edits, and terminal commands. `token-goat uninstall --vscode` (add `-p`/`--project` for the project scope) removes only token-goat's server entry, guidance block, and hooks, and keeps the hooks if `--copilot` still uses them.
+
+**Visual Studio** (2022 17.14 or later, or 2026): `token-goat install --visualstudio` adds the same `servers` entry to `%USERPROFILE%\.mcp.json` and a routing block to `%USERPROFILE%\copilot-instructions.md` (Visual Studio 2026 reads that file). With `-p`/`--project` it writes `.mcp.json` and `.github/copilot-instructions.md` in the solution folder instead. Visual Studio has no agent hooks, so token-goat works there through its MCP tools and instructions only: no read dedup, hints, image shrink, or output folding. Two switches in Visual Studio turn it on: the Tools > Options checkbox for custom instructions, and the token-goat tools in the chat Tools picker, since new MCP tools start disabled. `token-goat uninstall --visualstudio` (add `-p` for the project) removes only token-goat's entry and block. See [Visual Studio users](docs/install.md#visual-studio-users).
+
+**Zed**: `token-goat install --zed` registers token-goat as an MCP context server in Zed's `settings.json` (user scope only — Zed has no project-local equivalent). Zed's first-party agent has no hooks API at all, so this is MCP tools only, the same limits as Visual Studio above: no read dedup, hints, image shrink, or output folding. Enable the token-goat server under Zed's Agent panel tools list after installing; new MCP servers start disabled. `token-goat uninstall --zed` removes the entry and its generated shim script. See [Zed users](docs/install.md#zed-users).
+
+**Cursor**: `token-goat install --cursor` registers token-goat as an MCP server in `~/.cursor/mcp.json` (`-p`/`--project` for `<project>/.cursor/mcp.json`). This never touches `~/.cursor/hooks.json`: Cursor already imports Claude Code's hooks from `~/.claude/settings.json` by default, so a plain `token-goat install` for Claude Code already gets hooks running in Cursor too, with no separate Cursor hooks file to maintain or risk clobbering. `token-goat uninstall --cursor` removes only the MCP entry. See [Cursor users](docs/install.md#cursor-users).
+
+**JetBrains** (WebStorm, IntelliJ, PyCharm, Rider, PhpStorm): no integration today — no hooks, no MCP, no terminal filter. See [JetBrains IDEs users](docs/install.md#jetbrains-ides-webstorm-intellij-pycharm-rider-phpstorm-users) for why and what a Copilot-for-JetBrains user might already get for free.
+
+The optional source-controlled extension lives in `vscode-extension/`. Build and install its VSIX manually; `--vscode` intentionally does not copy or install extensions:
 
 ```text
 cd vscode-extension
@@ -454,24 +405,11 @@ npx @vscode/vsce package
 code --install-extension token-goat-vscode-0.1.0.vsix
 ```
 
-Its commands call the local CLI and use `workbench.action.chat.open` to
-prefill chat. They never submit chat automatically.
+Its commands call the local CLI and use `workbench.action.chat.open` to prefill chat. They never submit chat automatically.
 
-Installing the extension is an alternative to `install --vscode`, not an
-addition to it: the extension contributes the MCP decoder itself through VS
-Code's `mcpServerDefinitionProviders` contribution point, so VS Code starts
-`token-goat mcp-serve` on demand and there is no `mcp.json` to write and no
-window to reload. That path needs VS Code 1.101 or newer, which the
-extension's `engines` field requires. `install --vscode` remains the way to
-configure the decoder without the extension — for Copilot in an editor that
-has no extension installed, or for any other MCP client.
+Installing the extension is an alternative to `install --vscode`, not an addition to it: the extension contributes the MCP decoder itself through VS Code's `mcpServerDefinitionProviders` contribution point, so VS Code starts `token-goat mcp-serve` on demand and there is no `mcp.json` to write and no window to reload. That path needs VS Code 1.101 or newer, which the extension's `engines` field requires. `install --vscode` remains the way to configure the decoder without the extension — for Copilot in an editor that has no extension installed, or for any other MCP client.
 
-If the extension is running somewhere that contribution did not take effect,
-it falls back to calling `token-goat mcp-status --vscode` (add
-`-p`/`--project` for the workspace scope too) to check whether `mcp.json`
-already configures the decoder, and offers to run `install --vscode` if not —
-the same path resolver `install`/`uninstall` write against, so the two can
-never drift on where `mcp.json` lives or what key name it looks for.
+If the extension is running somewhere that contribution did not take effect, it falls back to calling `token-goat mcp-status --vscode` (add `-p`/`--project` for the workspace scope too) to check whether `mcp.json` already configures the decoder, and offers to run `install --vscode` if not — the same path resolver `install`/`uninstall` write against, so the two can never drift on where `mcp.json` lives or what key name it looks for.
 
 **Copilot CLI** — add it to `~/.copilot/mcp-config.json`:
 
@@ -494,12 +432,16 @@ never drift on where `mcp.json` lives or what key name it looks for.
 
 **What the index actually holds, in plain terms.** The point of a surgical read is returning a function body without the file around it, which means the database stores those bodies. `symbols.body` holds the source text of every indexed symbol, `symbols.docstring` its doc comment, `refs.context` the line around each reference, and `chunks.text` the passages that semantic search embeds. There is also a full-text index over the bodies and docstrings. So the database is not a list of names and line numbers: it is a substantial copy of your source, sitting in a plain unencrypted SQLite file outside the repository.
 
+**How branch switches work.** The database tracks the active working tree by absolute path, not git branches or commit history. When branches switch, the index updates to match what is currently on disk. In-session commands like `git checkout` or `git switch` trigger a hook that queues changed files for reindexing. If branches switch in another terminal, token-goat catches drifted files during session-start reconciliation, and surgical reads self-heal on the fly if they hit a modified file. For frequent multi-branch work, consider `git worktree`. Each worktree gets its own directory and distinct index, eliminating reindexing churn between branches.
+
 The file-by-file table for each harness, and the path that file sits at: **[What gets installed](docs/install.md#what-gets-installed)** (see also **[Permissions & auto-approval](docs/install.md#command-auto-approval-and-permissions)**).
 
 ## Zero maintenance
 
 Hooks fire automatically on every tool call once installed — nothing to start or restart there. The background worker is a separate, manual step: `token-goat worker start` launches it as a detached process, `token-goat worker status` checks it, `token-goat worker stop` kills it. It restarts itself automatically if it crashes or gets killed while the machine is running — an edit hook checks its liveness and respawns it, rate-limited to about once every 5 minutes. It does not survive a reboot or logout, though; re-run `worker start` after either. `token-goat uninstall` removes the hook entries, `CLAUDE.md` block, and skill directory, but does not touch a running worker — stop it separately with `token-goat worker stop` if you no longer want it running.
 
+Hooks also answer faster after the first call. That call starts a small resident process, the hook server, and later hook calls go to it instead of starting Node and loading token-goat each time. In measurements on Windows that took a hook call from 110 to 135 ms down to about 70 ms in Claude Code, Codex, Copilot CLI and VS Code chat, and a read command such as `token-goat section` from 122 ms to 60 ms when its output goes to the agent rather than a terminal. You never start it yourself. It stops after 30 minutes idle, after an upgrade, when you turn it off, and when `uninstall --purge` runs. `token-goat hook-server status` shows what is running and `token-goat hook-server stop` stops it. To turn it off, set `server = false` under `[hooks]` in your global config, or `TOKEN_GOAT_HOOK_SERVER=0`. A project's `.token-goat.toml` cannot change this setting, because one server answers every project.
+
 To move to a newer release, `token-goat upgrade` installs it from npm and then re-runs `token-goat install`, so your hooks and integration manifests point at the build that just landed. `token-goat upgrade --check` reports whether one is available without installing anything, and `--json` gives the same answer for a script. Both go quiet when `network.offline` is set, and `token-goat doctor` mentions an available update at the end of its report.
 
 ## Verify
@@ -513,7 +455,7 @@ token-goat stats
 
 ### Confirming hooks are wired
 
-`doctor` checks the binary, worker, database, and disk. It does not inspect `settings.json` hook wiring. To confirm all three hooks are present, re-run `install`:
+`doctor` checks the binary, worker, database, and disk, and whether the installed Claude Code, Codex and Copilot hook shims match the running build. It does not inspect `settings.json` hook wiring. To confirm all three hooks are present, re-run `install`:
 
 ```
 token-goat install

package/SECURITY.md

@@ -99,6 +99,20 @@ Direct dependencies with a forward patch are kept current rather than pinned: `p
 
 For a scanner that ingests a bill of materials rather than a lockfile, `npm run sbom` writes CycloneDX 1.5 to stdout.
 
+## What actually runs
+
+The supply-chain attacks worth planning for no longer run at install time. Blocking `preinstall` and `postinstall` hooks answers the previous generation; the current one ships a package that installs cleanly, passes a static scan, and hides its payload inside a method the host application is certain to call once it starts working normally. Nothing about that install looks wrong, so nothing examining the install can find it.
+
+What the class still needs is a package in the tree, which is why the number that matters here is how few there are. Exactly one package is required at runtime: [`jsonc-parser`](https://www.npmjs.com/package/jsonc-parser), bundled into the shipped artifact at build time. Every other production dependency is `optional` and resolved lazily, so its code runs only if you use the feature that needs it, on an install that actually has it. Skip optional packages, as the second row of the table above does, and the whole install is two packages: Token-Goat and that one dependency.
+
+Which names may appear in that tree is pinned in [`tests/guards/runtime_dependency_set_is_locked.test.ts`](tests/guards/runtime_dependency_set_is_locked.test.ts) and checked on every CI run. A dependency that arrives through a routine version bump fails the build and names itself, rather than quietly beginning to execute in every install. Installs themselves are `npm ci` against the committed lockfile, so resolution cannot drift from what was reviewed, and Dependabot proposals wait seven days ([`.github/dependabot.yml`](.github/dependabot.yml)) rather than adopting a version on the day it is published.
+
+The lockfile is not the only thing that decides what loads, so it is not the only thing checked. [`tests/guards/bundle_runtime_imports_are_reviewed.test.ts`](tests/guards/bundle_runtime_imports_are_reviewed.test.ts) reads the built artifact instead and requires every package name it can resolve at run time to have been reviewed — including the ones the lockfile cannot show you, such as a module the host agent supplies out of its own process. Installing this package runs nothing: it declares no `preinstall`, `install`, or `postinstall` script, which [`tests/guards/lifecycle_script_is_published.test.ts`](tests/guards/lifecycle_script_is_published.test.ts) keeps at zero rather than leaving to habit. `npm audit signatures` runs in CI and before every commit that moves the lockfile, so a tarball altered after publication fails rather than installs.
+
+Releases are built and published by two separate jobs ([`.github/workflows/publish.yml`](.github/workflows/publish.yml)). Everything that executes dependency code — `npm ci`, the suite, the build — runs in a job that holds no registry credential, and the only thing crossing into the publishing job is the built bundle. That job installs nothing and passes `--ignore-scripts`, so no lifecycle hook can run beside the upload; [`tests/guards/publish_job_runs_no_dependency_code.test.ts`](tests/guards/publish_job_runs_no_dependency_code.test.ts) holds the split. This does not make a release untamperable, and it is not claimed to: the build itself is a bundler running dependency code, so the artifact is the residual risk. It is a smaller one than a writable checkout sharing a job with a publish token.
+
+None of this inspects what a dependency does once it runs. It bounds how much third-party code can run at all, and makes any change to that set something a person has to agree to.
+
 ## Verifying what you installed
 
 Every published version is built and pushed by one workflow, [`.github/workflows/publish.yml`](.github/workflows/publish.yml), which runs only when a GitHub release is published (or manually, and then only from `main`). It publishes with npm provenance, so npm holds a signed attestation tying the tarball to the commit and workflow run that produced it. Nothing is ever published from a developer workstation.

package/dist/{token-goat-chunk-OZRSREKR.mjs → token-goat-chunk-2AWQ2R5X.mjs}

@@ -11,8 +11,8 @@ import {
   openReadonlySqlite,
   runReadOnlySqliteQuery,
   validateReadOnlySelect
-} from "./token-goat-chunk-DA43OE7L.mjs";
-import "./token-goat-chunk-OSUFN2FV.mjs";
+} from "./token-goat-chunk-PQ53BSCF.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
 import "./token-goat-chunk-NMTKNYGF.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {

package/dist/{token-goat-chunk-BH4ZVRB2.mjs → token-goat-chunk-2NNUA2LR.mjs}

@@ -2,13 +2,13 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   loadConfig
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
-import {
-  VERSION
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-TGOXNAHW.mjs";
 import {
   displaySafeJson
 } from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  VERSION
+} from "./token-goat-chunk-MELOKFDJ.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";