Skip to content

feat(plugin): a Claude Code plugin for context-guru, with the #141 review's blockers fixed - #160

Open
amiddavid wants to merge 3 commits into
mainfrom
feat/context-guru-plugin
Open

feat(plugin): a Claude Code plugin for context-guru, with the #141 review's blockers fixed#160
amiddavid wants to merge 3 commits into
mainfrom
feat/context-guru-plugin

Conversation

@amiddavid

Copy link
Copy Markdown
Collaborator

Split out of #141, as the review asked. All six of its blocking findings were in the plugin, and none of them were in the release plumbing or the conformance work — so those stay in #141 and can land without waiting for this.

Stacked on #141 (it needs the --listen and --version flags, and the expand-injection gate). Merge #141 first.

The six blocking findings

# Finding Fix
1 uninstall killed the user's own session and left the proxy running pidfile + socket-owner fallback; --listen puts the port in argv; no pattern matching
2 install.sh could not install, and its documented go install fallback was absent implemented, plus download_failed as a reported outcome and a key=value contract that curl no longer breaks
3 A dead proxy hangs silently and status cannot diagnose it new UserPromptSubmit hook — the only thing that runs without a model call
4 cache advertised context_guru_expand fixed in #141, where the gate belongs; the wrong claims here are corrected
5 The backup destroyed the user's undo; uninstall did not restore what it replaced O_EXCL + microsecond stamps; the replaced value is recorded and restored
6 The atomic write widened a credential file's mode, and replaced symlinks mode preserved, path resolved first

On finding 1, the mechanism is worth repeating because the fix follows from it: the port was passed through LISTEN_ADDR in the environment, so pkill -f "context-guru-proxy.*$PORT" matched no proxy — and did match the shell running it, which is the session's own Bash tool. The narrow pattern the skill offered as the safe alternative was the one that bit. So the fix is a handle, not a better pattern: a pidfile, a socket-owner fallback, and a check that the PID is ours before killing it.

On is_ours, I did not take the review's suggestion. It proposed matching http://(127.0.0.1|localhost|[::1]):\d+/anthropic as ours, so that changing the configured port stops reporting a conflict against context-guru itself. A test caught why that is unsafe: litellm's default is http://127.0.0.1:4000/anthropic, so a URL-shape rule lets uninstall delete somebody else's routing — and the existing test asserting exactly that started failing. Two local proxies are indistinguishable by URL, so add now records the URL it wrote and later runs read that record. Anything unrecorded stays a conflict, for add and remove alike. Same outcome for the port-change case, without the claim.

Smaller items, all addressed

The dead dashboard link (it advertised /dashboard/ and never passed --dashboard — a 404 as the first line the plugin ever prints; now served, with its database outside the user's repository); backups pruned to 10; the upgrade path documented; --idle-exit's 24h identified as the plugin's value rather than the flag's default; and the zero-value conditions stated where a first-run user reads them — including the one that was documented nowhere and is the commonest for a casual trial: outside a git repository there is no environment snapshot, so the saving is exactly zero. /context-guru:status now checks for it, and no longer reads acted: 0 / savings_pct: 0 as a verdict, since those count content removal and this component relocates a breakpoint.

Verification

Scripts tested from Go, so go test ./... and CI cover them. Seven mutations, each proven to have landed in the source before its result was allowed to count, each failing the named test and passing when restored — full output in the commit body.

One process note worth having in the open: my first attempt at the backup mutation reverted only the timestamp granularity and left the O_EXCL retry loop in place, so the filename was still unique and the test passed — proving nothing about the defect. Reverting half a fix is its own route to a vacuous result. The recorded run restores the original function whole, and then the test fails with "both operations reported the same backup path".

Still not verified

The plugin has not been installed into a real Claude Code session end to end, because install.sh resolves a GitHub release and no tag has published assets yet. That is the first thing to do once #141 merges and a tag exists, and I would not point a stranger at the two-command flow before then.

🤖 Generated with Claude Code

@amiddavid
amiddavid force-pushed the feat/context-guru-plugin branch 3 times, most recently from 3627248 to e9be584 Compare September 1, 2026 10:57
@amiddavid
amiddavid force-pushed the feat/context-guru-plugin branch from e9be584 to 56790db Compare September 1, 2026 11:19
amiddavid added a commit that referenced this pull request Sep 1, 2026
Review of #161 found the same defect this PR is themed on — claims that are not true — in seven more
places, one of them in shipped code. All seven fixed, plus the `HasOffload` unit test the reviewer
raised without asking for.

Rebased onto current main first, so #142's preset-table guard and the preset pass below cannot
re-fix or re-break each other.

## Merge-blocking

**1. `proxy/proxy.go` named `mcp` as offloader-free.** It is not: `smartcrush` implements
components.Offload, which this PR's own test asserts (`wantAdd: true`) and its own mirror-image
mutation proves. I had corrected the test and left the comment wrong — the copy a future reader
actually trusts.

The fix deletes the list rather than correcting it. The comment now names the shapes affected
(`off`, `safe`, any cachesplit-only configuration) and then says why enumerating presets here is the
wrong move: a list in a comment is a second source of truth, and this one was wrong about `mcp` on
its first draft. That is the whole argument for gating on the interface.

**2. Five sites named the `cache` preset, which does not exist on this base.** It is #141's, and it
reached here in the wholesale copy of `proxy/proxy.go` this PR already admits to, then travelled
into the test files when they were split out of that branch. Reworded to name configurations that
exist here; the underlying defect they describe is unchanged and still reproduces on `off` and
`safe`.

**3. `proxy/counttokens_test.go` carried copy-paste artifacts vet and gofmt cannot see.** A
duplicated 3-line doc comment, and a 20-line orphan documenting a function that lives in
`expandgate_test.go` under a different name and citing a test that exists nowhere. Both from the
same cause: my splitter took each test's doc comment by scanning back to the previous blank line,
which swallowed the FOLLOWING test's comment as a trailing block. A third artifact the review did not
list is fixed too — `expandgate_test.go`'s doc comment still described "the preset's promise" and
cited `docs/how-to/install-plugin.md` and an install skill, both of which belong to #160.

## The rest

**4.** `docs/reference/config.md` and `docs/components.md` said `auto` injection has exactly two
conditions. It has three. Both now say so, and say what the third is for. The cache-stability
argument those passages make is unaffected — a pipeline does not change turn to turn either — so it
gained a member rather than needing a rewrite.

**5. `make build` now sets `CGO_ENABLED=0`.** The docs could claim "no C toolchain" all they liked
while step 1 of the quickstart was `make build`, which needed one because the Makefile exported
`CGO_ENABLED=1` for every target. Pointing readers at `build-static` would have fixed the sentence;
making the DEFAULT build pure Go makes the claim true of the command the docs tell people to run.
`CGO_ENABLED=1` stays for the test targets, where `-race` requires it, and the comment says exactly
that. Verified: `CC=/nonexistent make build` produces a statically linked binary.

README, CLAUDE.md and the quickstart no longer require a C toolchain. All five remaining
`codesmart`-is-the-default sites are corrected — including two in `config/config.go`, which is how
the claim spread to five documents: it sat three lines from the flag that disproves it.

**6.** `docs/setup.md` overstated its own evidence, which is the exact sin this PR is about. It
claimed CI removes the C compiler from `PATH` (with cgo off the toolchain never consults `CC`; that
variable is a tripwire, not the mechanism) and that cross-compilation to four targets is asserted,
when CI builds native linux/amd64 only. Now says what CI actually does, and states separately that
the other three targets were verified by hand and are asserted at release time. Same overstatement
fixed in the `ci.yaml` comment.

**7.** `ci.yaml` promised a linked issue and linked nothing, and named a different flake than the PR
body did. Both are real; the comment is about the campaign one, and now links #163.

## HasOffload unit tests

`./components`: nil-safe, empty pipeline (the A/B control arm), reformatters-only, and an offloader
in three positions. Revert-verified both ways — always-true fails the empty and reformatter cases,
always-false fails the offloader cases.

A registry-walking test was supposed to make it rot-proof, and **it skipped**: registrations happen
in `components/all`, so a test inside `components` can neither see them nor import the package that
does. A test that skips reads as coverage and is not, so it moved to `components/all`, where it
runs — 21 of 21 registered components, 13 implementing Offload. It fails if either count is zero,
because an all-false or all-true population would agree with a broken HasOffload.

Full `go test ./...`, `go vet ./...` and `gofmt -l` clean; doc link/anchor checker re-run over every
document touched.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>
@amiddavid
amiddavid force-pushed the feat/context-guru-plugin branch from 56790db to 295f551 Compare September 1, 2026 16:56
OsherElhadad pushed a commit that referenced this pull request Sep 1, 2026
…pand-tool gate, count_tokens, C-toolchain claim, preset facts) (#161)

* fix: defects that surfaced while building the distribution funnel

None of this is distribution work. Every item is a defect in code or docs that already shipped,
found while doing #141, and split out at review request so it can be judged on its own — and so it
can land whether or not the funnel does.

## 1. The expand tool was advertised where no marker can exist

`expand.Inject` under `auto` gated on "the request declares tools" and "the store persists".
Nothing asked whether the pipeline could produce a `<<cg:HASH>>` marker at all, so an
offloader-free pipeline declared `context_guru_expand` to the provider — and every call against it
must fail, because there is nothing in the Store to resolve. Measured on the real gateway route:

  tools SENT by client    : [Read Bash]
  tools FORWARDED upstream: [Read Bash context_guru_expand]

Affected `safe` and any cachesplit-only configuration, and — the one that matters most — **`off`,
the A/B control arm**. A control that carries an extra tool declaration is not a control, and every
measurement taken against it was comparing two arms that differed by more than the pipeline.

The cost when it fires is a wasted round trip and a step of the user's turn: on a transcript
containing marker-shaped text (this repo's own docs contain literal `<<cg:HASH>>`), a model calls
the tool and gets "[expand: original for id ... is no longer available]".

It was also a code-vs-comment contradiction, which is why nobody noticed: `Options.InjectExpand`
documented the gate as requiring "an expandable marker", while `expand/inject.go` says "No marker
condition, deliberately" three lines from the code. Both now describe what happens.

`components.Pipeline.HasOffload()` answers by TYPE ASSERTION, not a list of component names: a
name list is a second copy of "which components are lossy" and drifts the moment somebody adds
one. `components.Offload` cannot be implemented by accident — it requires returning cache keys
proving the original was stashed. Marker independence is preserved (the property that keeps the
tools array byte-stable across a session, and hence the prefix cached): a pipeline does not change
turn to turn.

**Ten existing tests changed fixture.** Every test of the expand loop hand-seeds the Store to
simulate an offload, but built its handler with `pipeline: []` — which cannot offload anything.
Harmless while injection ignored the pipeline; now they use `offloadCapablePipeline` (`[linecap]`,
which does not act on their short bodies). No assertion was weakened; each fixture now matches its
own premise.

## 2. `POST /v1/messages/count_tokens` was not served

Absent it, a client asking how big its context is gets a 404 and falls back to working it out with
**inference requests** — billed calls, caused by a proxy whose purpose is to reduce them. Cheap to
add, and it costs every routed user, not only the funnel.

Forwarded verbatim, with no pipeline. Returning the compacted count would be smaller and would be
wrong in the dangerous direction: the client budgets its own transcript from this number, and
because every component fails open, the next request could forward the full body and take a 400.
Over-reporting is recoverable; under-reporting is a failed turn. The cost of that choice is now
documented in `docs/reference/routes.md`, where the route was absent entirely — a routed session
self-compacts earlier than it needs to (115,933 reported vs 32,802 forwarded on a measured body).

The hosted branch has tests, because that branch is the only thing standing between the
multi-tenant service and an unmetered open forwarder that would send OUR credential upstream.

## 3. Our own docs said the binary needs a C toolchain

`docs/setup.md`, `docs/hosted.md` and `docs/get-started/quickstart-proxy.md` all told evaluators to
install one. It is needed for `go test -race` and for the optional `cg_skeleton` tag, not for the
binary. setup.md went further and named **bifrost's tokenizer** as a cgo dependency, which it never
was — o200k_base is embedded (`internal/tokens/tokens.go`).

Asserted rather than re-claimed: a new `purego` CI job builds with `CGO_ENABLED=0` and
`CC=/nonexistent-c-compiler`, checks the artifact is statically linked, starts it and probes
/healthz. It also runs the packages whose behaviour depends on which components compile in —
because `build-test` runs exclusively with `CGO_ENABLED=1` (the race detector needs it), so
`TestEveryPresetBuilds` had **never executed in the configuration a user would build**. That guard
exists for exactly the `preset: coding` / `unknown component "skeleton"` breakage.

## 4. Preset facts stated outside the guarded files (#143, #145)

- The binary defaults to **`house`**; five sites said `codesmart` (README x3,
  `docs/reference/config.md`, `docs/get-started/quickstart-proxy.md` — the last is step 2 of the
  first page anyone runs). Anyone running the binary bare while reading those measured a different
  configuration than the published SWE-bench numbers describe.
- README's `codesmart`/`codesafe` pipeline lists and
  `docs/get-started/connect-ibm-service.md`'s "Default pipeline" were stale — naming `toon`,
  retired after acting 0 of 5,752 production requests, and omitting components that do run.
  The IBM page's omission of `toolfilter` matters most: that page is what a prospective hosted
  tenant reads to decide what the service does to their traffic.

All regenerated from the `presets` map. The two tables inside #142's drift guard are untouched
here; these are the sites that guard cannot reach.

## Verification

Five mutations, each proven to have landed in the source before its result was allowed to count:

  expand injection ungated        -> TestExpandToolIsAdvertisedOnlyWhereMarkersCanExist FAIL
    on cachesplit-only, `safe`, and `off`
  HasOffload always false         -> same test FAIL on `mcp` and the offloader pipeline: "mints
    markers but no longer advertises the expand tool, so a model cannot recover what it offloaded"
  count_tokens route unregistered -> TestCountTokensIsServed FAIL (404)
  count_tokens rewrites the body  -> TestCountTokensIsServed FAIL
  hosted auth removed             -> TestCountTokensHostedRequiresAuth FAIL (502, want 401)

The second is the mirror-image check: it proves the gate did not trade one silent defect for
another, an offloader whose output nothing can expand.

Two things I got wrong on the way, recorded because both were caught by tests rather than by me:

- I first asserted `mcp` had no offloader. `smartcrush` implements `components.Offload`
  (`components/offload/smartcrush.go`), so that pipeline genuinely mints markers and genuinely
  needs the tool. The case now asserts the opposite, with the reason — and it is the argument for
  asking the interface rather than keeping a hand-written list.
- Copying `proxy/proxy.go` wholesale from the older distribution branch onto current main silently
  reverted #155's `effPreset`/`notePreset` work. `TestCompactRowNamesThePresetThatRan` — a test I
  had never read — failed with "the dashboard names a pipeline that did not run". The file was
  restored from main and the two edits re-applied on top; #155's change is intact.

`go build ./...`, `go vet ./...`, `gofmt -l` and the full `go test ./...` are clean.

One unrelated flake seen once and not reproduced: `TestConcurrentCallsDoNotRaceOnTheGateHistogram`
failed in a full-suite run with "no single-flight follower ran ... the race was never exercised",
then passed 8/8 in isolation and in two further full suites, and passes on clean main. Reported
separately rather than papered over.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>

* ci(purego): run one package binary at a time

The new job runs `go test` over five package trees, and `go test` starts up to GOMAXPROCS package
binaries in parallel. On a 2-core CI runner that added a second heavily-parallel run of the proxy
package per PR, and under that contention a timing-sensitive control-plane test from #150
(TestCtlGetCampaignAggregatesPredictedAndRealPerTenant) failed on two unrelated PRs — then passed on
a re-run of the same commit, and passes 3/3 whole-package on a 16-core box against both main and the
affected branch. Filed as #163.

Hunting that flake is not this job's business. Not provoking it is: `-p 1` costs about a minute and
removes the contention this job introduced, without dropping any coverage.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>

* fix: make this PR's own prose true, and unit-test HasOffload

Review of #161 found the same defect this PR is themed on — claims that are not true — in seven more
places, one of them in shipped code. All seven fixed, plus the `HasOffload` unit test the reviewer
raised without asking for.

Rebased onto current main first, so #142's preset-table guard and the preset pass below cannot
re-fix or re-break each other.

## Merge-blocking

**1. `proxy/proxy.go` named `mcp` as offloader-free.** It is not: `smartcrush` implements
components.Offload, which this PR's own test asserts (`wantAdd: true`) and its own mirror-image
mutation proves. I had corrected the test and left the comment wrong — the copy a future reader
actually trusts.

The fix deletes the list rather than correcting it. The comment now names the shapes affected
(`off`, `safe`, any cachesplit-only configuration) and then says why enumerating presets here is the
wrong move: a list in a comment is a second source of truth, and this one was wrong about `mcp` on
its first draft. That is the whole argument for gating on the interface.

**2. Five sites named the `cache` preset, which does not exist on this base.** It is #141's, and it
reached here in the wholesale copy of `proxy/proxy.go` this PR already admits to, then travelled
into the test files when they were split out of that branch. Reworded to name configurations that
exist here; the underlying defect they describe is unchanged and still reproduces on `off` and
`safe`.

**3. `proxy/counttokens_test.go` carried copy-paste artifacts vet and gofmt cannot see.** A
duplicated 3-line doc comment, and a 20-line orphan documenting a function that lives in
`expandgate_test.go` under a different name and citing a test that exists nowhere. Both from the
same cause: my splitter took each test's doc comment by scanning back to the previous blank line,
which swallowed the FOLLOWING test's comment as a trailing block. A third artifact the review did not
list is fixed too — `expandgate_test.go`'s doc comment still described "the preset's promise" and
cited `docs/how-to/install-plugin.md` and an install skill, both of which belong to #160.

## The rest

**4.** `docs/reference/config.md` and `docs/components.md` said `auto` injection has exactly two
conditions. It has three. Both now say so, and say what the third is for. The cache-stability
argument those passages make is unaffected — a pipeline does not change turn to turn either — so it
gained a member rather than needing a rewrite.

**5. `make build` now sets `CGO_ENABLED=0`.** The docs could claim "no C toolchain" all they liked
while step 1 of the quickstart was `make build`, which needed one because the Makefile exported
`CGO_ENABLED=1` for every target. Pointing readers at `build-static` would have fixed the sentence;
making the DEFAULT build pure Go makes the claim true of the command the docs tell people to run.
`CGO_ENABLED=1` stays for the test targets, where `-race` requires it, and the comment says exactly
that. Verified: `CC=/nonexistent make build` produces a statically linked binary.

README, CLAUDE.md and the quickstart no longer require a C toolchain. All five remaining
`codesmart`-is-the-default sites are corrected — including two in `config/config.go`, which is how
the claim spread to five documents: it sat three lines from the flag that disproves it.

**6.** `docs/setup.md` overstated its own evidence, which is the exact sin this PR is about. It
claimed CI removes the C compiler from `PATH` (with cgo off the toolchain never consults `CC`; that
variable is a tripwire, not the mechanism) and that cross-compilation to four targets is asserted,
when CI builds native linux/amd64 only. Now says what CI actually does, and states separately that
the other three targets were verified by hand and are asserted at release time. Same overstatement
fixed in the `ci.yaml` comment.

**7.** `ci.yaml` promised a linked issue and linked nothing, and named a different flake than the PR
body did. Both are real; the comment is about the campaign one, and now links #163.

## HasOffload unit tests

`./components`: nil-safe, empty pipeline (the A/B control arm), reformatters-only, and an offloader
in three positions. Revert-verified both ways — always-true fails the empty and reformatter cases,
always-false fails the offloader cases.

A registry-walking test was supposed to make it rot-proof, and **it skipped**: registrations happen
in `components/all`, so a test inside `components` can neither see them nor import the package that
does. A test that skips reads as coverage and is not, so it moved to `components/all`, where it
runs — 21 of 21 registered components, 13 implementing Offload. It fails if either count is zero,
because an all-false or all-true population would agree with a broken HasOffload.

Full `go test ./...`, `go vet ./...` and `gofmt -l` clean; doc link/anchor checker re-run over every
document touched.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>

---------

Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>
…way conformance

Implements the local-distribution proposal (#130) minus the Claude Code plugin, which ships as its
own PR because all six blocking findings from the review of #141 live in it. Nothing here is held
behind that.

`docs/get-started/quickstart-proxy.md`, `docs/setup.md` and `docs/hosted.md` all told evaluators to
install a C toolchain and set `CGO_ENABLED=1`. That is true only for a `cg_skeleton` build.
setup.md went further and named bifrost's tokenizer as a cgo dependency, which it is not —
o200k_base is embedded (`internal/tokens/tokens.go`).

Verified directly on go 1.26.4 rather than taken from the proposal: `CGO_ENABLED=0` with default
tags builds all four release targets (linux/darwin x amd64/arm64, 27.1-33.5 MB stripped), `file`
reports "statically linked", `ldd` reports "not a dynamic executable", the binary starts and
answers /healthz, and `-tags cg_skeleton` fails under CGO_ENABLED=0 with the build-constraints
signature — confirming tree-sitter is the only C dependency.

- `.goreleaser.yaml`: a plain GOOS/GOARCH matrix, no cross-toolchains, no `brews:` block (the tap
  repo and release signing are an unowned question, and nothing may depend on a repo that does not
  exist).
- `.github/workflows/release.yaml`: a tag publishes, `workflow_dispatch` builds the same matrix as
  a snapshot. It asserts the pure-Go claim with `CC=/nonexistent-c-compiler`.
- `make build-static`. The Makefile keeps `CGO_ENABLED=1` because `go test -race` needs it, and the
  comment now says that is a test-time requirement — reading it as a shipping requirement is how
  the wrong claim reached the docs.

The funnel's default, chosen so a stranger can verify the claim by reading one line rather than
trusting four components. Not `safe`, whose extra components are lossless in meaning but still
rewrite the JSON.

Off by default; a gateway or eval-containers deployment must never self-terminate. A signal and the
watchdog converge on the SAME teardown, so the self-killing path cannot drift from the one known to
work. Two properties are load-bearing:

- **The keep-alive inverts "idle."** Pinging is what the proxy does precisely while no client
  traffic arrives — the quiet gap after `end_turn`, where 83.7% of the recoverable dollars sit. A
  pending ping both vetoes the exit and RESETS the clock, so retiring the last ping buys a full
  fresh threshold rather than exiting moments later.
- **Exit wipes the in-memory store.** `store.ValidateIdleExit` refuses anything below
  `max(2 x store.ttl_seconds, 1h)` at startup — ~5h34m at the default. 2x because the TTL is a
  sliding window. `NewMemory` now calls the same `Options.EffectiveTTL` the floor is computed from,
  so the two cannot drift.

All five items from the proposal, under the `cache` preset. Four were already correct and are now
pinned by tests; `POST /anthropic/v1/messages/count_tokens` was missing entirely — without it a
client counts context by issuing INFERENCE requests, billed calls added by a proxy sold on removing
them.

Five places promised it did not: `config/config.go`, `docs/reference/presets.md`,
`docs/how-to/choose-a-preset.md`, the plugin doc, and the install skill. Verified before fixing —
`[Read Bash]` in, `[Read Bash context_guru_expand]` out on the real gateway route.

Root cause was a code-vs-comment contradiction. `Options.InjectExpand` documented the gate as
requiring "an expandable marker"; `expand/inject.go` says "No marker condition, deliberately" and
the real conditions were mode, store-persists and has-tools. Nothing asked whether the pipeline
could produce a marker at all.

`components.Pipeline.HasOffload()` answers that by type assertion rather than a name list (a name
list is a second copy of "which components are lossy" and drifts the moment somebody adds one).
Under `auto`, injection now requires it. `always` still injects unconditionally — an operator who
asks for it by name gets it.

This also fixes `off`, the A/B control arm, which was carrying an extra tool declaration. Marker
independence is preserved, which is the invariant that matters for cache stability: a pipeline does
not change turn to turn, so the tools array stays byte-stable across a session.

**Ten existing expand tests changed fixture, and that is worth reading.** They hand-seed the Store
to simulate an offload, but built their handler with `pipeline: []` — a pipeline that cannot
offload anything. That was harmless only while injection ignored the pipeline. They now use
`offloadCapablePipeline` (`[linecap]`, which does not act on their short bodies), so each fixture
matches its own premise. No assertion was weakened.

- **`--idle-exit` was defeated by any health probe** (finding 7). `/healthz` and `/metrics` no
  longer count as activity: a probe on a schedule shorter than the threshold meant the exit NEVER
  fired and logged nothing to say so — measured, a 1h-threshold proxy reporting "idle for 1h3m0s"
  after 2h03m. A dashboard poll still counts, deliberately: a probe is not a viewer, and exiting
  under somebody who is watching is the worse failure.
- **A gateway may no longer self-terminate.** `--idle-exit` with `--upstreams` is refused at
  startup. That safety was previously accidental — it held only because hosted deployments run a
  liveness probe, which the change above stops counting.
- **The floor's refusal was logged after "listening"**, so a rejected configuration read as a
  crash. Both refusals moved earlier and into one testable `checkIdleExit`.
- **`--listen` and `--version` flags** (findings 2 and 12, which are the plugin's, but the flags
  are the core's). The address reached the process only through the environment, so no supervisor
  or `ps` could tell which port an instance held; and `buildinfo.Version` was reachable only via
  `/stats` on a running proxy, so an installer asking `--help` recorded "Usage of
  context-guru-proxy:" as the installed version.
- **Nothing tested the shipped configuration** (finding 9). A tag published without running any
  tests, and CI runs the suite only with `CGO_ENABLED=1` — so `TestEveryPresetBuilds`, which
  guards exactly the CGO-free artifact, was never executed in that configuration. The release
  workflow now runs a CGO-off suite over the packages whose behaviour depends on which components
  are compiled in, plus the full suite, before publishing. It also asserts `--version` answers.
- **`scripts/gate-a-purego.sh` was cited as proof in four places and is not in this PR**
  (finding 8). Those now cite the release workflow's own assert step, which exists here and fails
  the release if a cgo dependency escapes the `cg_skeleton` tag.
- **The savings claim was measured in the wrong regime.** −34.1% / 96.7% comes from a harness
  running tasks back-to-back inside the provider's 5-minute TTL, and is one task measured three
  times; this project's own interactive figure is $0.0298 across 1,127 sessions, with 1,105 of
  1,127 session starts reading zero from cache. Both are now stated, with the zero cases (outside
  a git repo, under the 1,024-token floor, non-Anthropic backend). The old citation pointed at
  `docs/results/context-guru.md`, which contains neither number.
- **`count_tokens` behaviour kept, consequence documented** (finding 10). It answers about the
  ORIGINAL body — over-reporting is recoverable, under-reporting costs a failed turn when a
  fail-open component reverts. What was undocumented is the cost: the client self-compacts earlier
  than needed (115,933 reported vs 32,802 forwarded). Now in `docs/reference/routes.md`, where the
  route was absent entirely. Its **hosted branch was wholly untested** — that branch is all that
  stands between the multi-tenant service and an unmetered open forwarder — so it now has one.
- `--idle-exit` and `--version` added to both flag tables; `bytes.NewReader` in counttokens.

Six mutations, each proven to have landed in the source before its result was allowed to count:

  expand injection ungated (the defect)   -> TestCachePresetAdvertisesNoExtraTool FAIL
    cache: sent [Read Bash], forwarded [Read Bash context_guru_expand]
    off:   sent [Read Bash], forwarded [Read Bash context_guru_expand]
  HasOffload always true                  -> same test FAIL, same two subcases
  HasOffload always false                 -> FAIL on the offloader subcase: "mints markers but no
    longer advertises the expand tool, so a model cannot recover what it offloaded"
  probes count as activity again           -> TestProbesDoNotDeferIdleExit FAIL ("two hours of
    nothing but liveness probes: idle past the threshold, but watchIdle never exited")
  gateway guard disabled                   -> TestCheckIdleExitRefusesAGatewaySelfTerminating FAIL
  count_tokens hosted auth removed         -> TestCountTokensHostedRequiresAuth FAIL (502, want 401)

The third mutation is the one worth noting: it proves the fix did not trade a silent defect for its
mirror image, an offloader whose output nothing can expand.

`go build ./...`, `go vet ./...`, `gofmt -l` and the full `go test ./...` are clean.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>
@amiddavid
amiddavid force-pushed the feat/context-guru-plugin branch from 295f551 to df96bd5 Compare September 1, 2026 18:01
CI validated on Go 1.25 while `go.mod` declared 1.26.4 and this PR's release workflow built on
1.26 — three numbers that have to agree, with nothing making them.

That is a distribution bug, not a housekeeping one. `purego` asserts that the SHIPPED artifact
builds with cgo off, and `release.yaml` builds the artifact people download; when those run
different toolchains from each other and from the module, the assertion describes a build nobody
ships. The `purego` job inherited the wrong pin from the job it was copied from, which is exactly
how the drift spread in the first place.

Fixed as a class rather than an instance: `go-version-file: go.mod` in all three places, so the
module file is the single source of truth and the next toolchain bump moves CI, the release build
and the module together or not at all. Typing `1.26` in three files would have fixed today's
symptom and left tomorrow's.

`check-latest` is dropped with the literals — it existed to pick up patch releases of a pinned
minor, and go.mod names an exact version.

Both workflows re-validated as YAML. The change can only really be proven by CI itself, which is
where the previous mismatch was invisible.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>
…view's blockers fixed

Split out of #141 as its own PR: all six of the review's blocking findings were in the plugin, and
the release plumbing and conformance work should not wait behind them. The core lands in #141.

`/plugin marketplace add rossoctl/context-guru` → `/plugin install` → `/context-guru:install`.
Three skills over four scripts and two hooks. Default routing scope is
`.claude/settings.local.json`: one repo, gitignored, `--global` an explicit opt-in — a base URL
pointing at localhost breaks Claude Code everywhere a dead proxy is routed.

**1. `/context-guru:uninstall` killed the user's own session and left the proxy running.** It ran
`pkill -f "context-guru-proxy.*${PORT}"`. The port was passed through `LISTEN_ADDR` in the
environment, so it appeared nowhere in the proxy's command line and the pattern matched no proxy —
while it DID match the shell running the `pkill`, i.e. the session's own Bash tool. A user runs
uninstall *because* their sessions are broken; this killed the session mid-command, reported
nothing removed, and left the port held.

Fixed with a handle rather than a better pattern: the starter passes `--listen` (so the port is in
`argv` and `ps` is honest) and writes a pidfile under `~/.local/state/context-guru`; uninstall kills
that PID, falls back to the socket's owner via `lsof`/`ss`, and confirms the process is ours before
killing anything. The skill also no longer offers a broader pattern as a fallback — on a host
running a production instance or a benchmark arm, that would take those down too.

**2. `install.sh` could not install anything, and its documented fallback was missing.** Strict
checksums now; `download_failed` (a tag with no assets) is documented as an outcome; the `go
install` fallback the header comment described is implemented; curl's stderr no longer breaks the
`key=value` contract the skill parses.

**3. A dead proxy is a silent, indefinite hang** — no output on either stream — and
`/context-guru:status` cannot diagnose it, because invoking a skill needs a model call, which is the
broken thing. New `check-proxy.sh` on `UserPromptSubmit`: it probes `/healthz`, tries to restart,
and otherwise prints what to do. A hook is the only thing that runs without a model turn. It never
blocks a prompt.

**4. The `cache` preset advertised `context_guru_expand`.** Fixed in #141 (the gate belongs in the
proxy); the docs and the install skill here no longer claim otherwise where they were wrong.

**5. `settings.py` destroyed the user's undo, and uninstall did not restore what it replaced.** The
backup stamp was second-granularity with an overwriting `copy2`, so an install→uninstall round trip
wrote both backups to the same path and the survivor held the POST-install state — the value it
existed to protect was gone from the file AND the backup. Now microsecond-stamped and created with
`O_EXCL`. And `replaced` was reported then forgotten, so after a `--force` install over somebody's
gateway, uninstall left them with no base URL at all; the replaced value is now recorded and
restored.

`is_ours` deserves a note. The review suggested matching `http://(127.0.0.1|localhost|[::1]):\\d+
/anthropic` as ours, to stop a port change reporting a conflict against context-guru itself. A test
caught why that is wrong: litellm's default is `http://127.0.0.1:4000/anthropic`, so a URL-shape
rule would let uninstall delete somebody else's routing. Two local proxies are indistinguishable by
URL, so `add` records the URL it wrote and later runs read that record. Anything unrecorded stays a
conflict — for both add and remove.

**6. The atomic write widened a credential-bearing file's mode** from 600 to 644 under the common
umask, and `os.replace` onto a symlinked `settings.json` replaced the LINK with a regular file, so a
dotfile-managed setup silently never received the edit. Mode is preserved; the path is resolved
first.

- **`start-proxy.sh` printed a dead dashboard link** — it advertised `/dashboard/` and never passed
  `--dashboard`, so the first line the plugin ever prints was a 404. Now passed, with
  `--dashboard-db` under the state directory: the default would write
  `./context-guru-dashboard.db` into the user's repository.
- **Backups accumulated forever** (one per add and per remove). Pruned to the newest 10.
- **The zero-value cases are now stated** where a first-run user reads them, and `status` checks the
  one that is both commonest and previously undocumented: **outside a git repository** there is no
  environment snapshot, so `cachesplit` skips and the saving is exactly zero. The status skill also
  no longer treats `acted: 0` / `savings_pct: 0` as a verdict — those count content removal, and
  this component relocates a breakpoint.
- **`--idle-exit`'s 24h is the plugin's value, not the flag's default** (which is 0 = never). Said
  so, along with probes not counting as activity.
- Upgrade path documented (`CONTEXT_GURU_UPGRADE=1`, `CONTEXT_GURU_VERSION`).

The scripts are tested from Go (`context-guru-plugin/plugin_test.go`) so `go test ./...` and CI
cover them. Seven mutations, each proven to have landed before its result counted:

  backup() back to overwriting copy2       -> TestBackupsDoNotClobberEachOther FAIL
    "both operations reported the same backup path ..., so one overwrote the other"
  uninstall stops restoring                -> TestUninstallRestoresTheBaseURLItReplaced FAIL
    restored="" want "https://gateway.corp.example/anthropic"; env left {ANTHROPIC_AUTH_TOKEN:keep}
  mode no longer preserved                 -> TestSettingsPreservesFileMode FAIL
  realpath removed                         -> TestSettingsFollowsASymlink FAIL
  checksum fail-open again                 -> TestInstallRefusesAnUnverifiedDownload FAIL
  port back in the environment             -> TestHookMakesTheProxyIdentifiable FAIL
  pidfile no longer written                -> TestHookMakesTheProxyIdentifiable FAIL

One of those is worth recording as a process note: my first attempt at the backup mutation reverted
only the timestamp granularity and left the `O_EXCL` retry loop in place, so the name was still
unique and the test passed — proving nothing. Reverting half a fix is its own way to get a vacuous
result. The run above restores the original function whole.

Pre-existing coverage still passes: settings merge/conflict/removal/backup, and the hook's silence
in unrouted projects, idempotence, non-failure when the binary is missing, and its wait for
`/healthz`.

**Still not verified end to end in a real Claude Code session**, because `install.sh` resolves a
GitHub release and no tag has published assets yet. That is the first thing to do once #141 merges
and a tag exists.

Assisted-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: DAVID AMID <DAVIDA@il.ibm.com>
@amiddavid
amiddavid force-pushed the feat/context-guru-plugin branch from df96bd5 to e4e89ec Compare September 2, 2026 06:03
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

Status: New/ToDo

Development

Successfully merging this pull request may close these issues.

2 participants