v1.1.1

ken v1.1.1 — crypto/tls CVE fix + dependency updates

A patch release. It closes a reachable standard-library TLS vulnerability and folds in routine dependency updates. No API, wire-format, or default changes from 1.1.0 — a drop-in upgrade.

🔒 Security

• Toolchain go 1.26.4 → 1.26.5 fixes GO-2026-5856 — an Encrypted Client Hello privacy leak in the standard library's crypto/tls. ken's govulncheck CI gate (added in 1.1.0) flagged it as reachable, with real call paths through the MySQL introspection TLS handshake and the model-fetch HTTPS client. The fix is a single go-directive bump in go.mod, which propagates to every CI job (all read go-version-file: go.mod); govulncheck ./... now reports 0 affecting vulnerabilities. No source changes.

📦 Dependencies

No ken API changes; the full test suite and govulncheck are green on the combined tree.

• github.com/townsendmerino/aikit v1.5.0 → v1.9.0 — the extracted algorithm packages (BM25 / embed / ann / encoder / chunk / fuse / topk).
• modernc.org/sqlite v1.52.0 → v1.53.0 — pure-Go SQLite driver (Tier-2 DB indexing).
• github.com/odvcencio/gotreesitter v0.20.2 → v0.20.5 — pure-Go tree-sitter (treesitter chunker + Arm B enrichment).
• actions/checkout v6 → v7 (CI).

Install / upgrade

# Homebrew (macOS/Linux) — ken ships as a cask
brew upgrade --cask ken     # new install: brew install --cask townsendmerino/tap/ken

# Windows (Scoop)
scoop update ken            # new install: scoop bucket add townsendmerino https://github.com/townsendmerino/scoop-bucket; scoop install ken

# Or with Go
go install github.com/townsendmerino/ken/cmd/ken@v1.1.1
go install github.com/townsendmerino/ken/cmd/ken-mcp@v1.1.1

No config changes required. Upgrading is recommended for the TLS CVE fix if you use ken-mcp's remote-clone or MySQL Tier-2 introspection paths.

Full changelog: CHANGELOG.md · compare v1.1.0...v1.1.1

ken v1.1.0 — security hardening + int8 reranker by default

A feature-and-hardening release. The int8 reranker becomes the default now that it's free, output: "json" reaches the last tool, the remote-clone path closes its two known SSRF gaps, and a govulncheck gate joins CI.

No breaking changes. mcp.Run / mcp.NewServer / the chunk.Chunker interface and the MCP wire format are unchanged from 1.0. The int8 default and the new KEN_MAX_CLONE_BYTES knob are both backward-compatible — existing configs keep working.

Highlights

⚡ int8 reranker is now the default

aikit v1.5.0 fixed the q8 path, so int8 now matches f32 reranker latency (50-doc cold: 7.35 s vs 7.75 s on arm64) at ~21× less runtime memory (18 MiB vs 379 MiB) and ¼ the weight footprint (~140 MB resident vs ~547 MB) — with cosine 0.997 vs f32, unchanged ranking quality. KEN_MCP_RERANK_QUANT and --rerank-quant now default to int8; pass f32 for the full-precision path. No re-download needed — LoadQ8 quantizes your existing CodeRankEmbed snapshot in-process.

This reverses the "int8 is slower on Apple Silicon" note from 1.0.1 — that was the pre-fix aikit path.

🧩 All nine MCP tools now speak JSON

recently_changed was the last markdown-only tool; it now accepts output: "json" and returns a typed RecentlyChangedResponse (considered-count + per-commit hash / short_hash / subject / author / RFC3339 timestamp / changed_files), built from the same rows as the markdown render so the two can't drift.

🔒 Security

• Clone SSRF guard hardened + a byte cap. ken-mcp's remote-repo clone now re-validates the resolved IP at connect time and dials it literally (TLS still verifies the hostname via SNI) — closing the DNS-rebinding TOCTOU the pre-flight check couldn't catch, including redirects to internal hosts. It also byte-caps the clone stream (KEN_MAX_CLONE_BYTES, default 2 GiB) so a hostile server can't stream an unbounded/pathological pack. Both checks honor KEN_ALLOW_PRIVATE_CLONE_TARGETS=1.
• govulncheck CI gate. Go's symbol-level vulnerability scanner now runs on every push. Bringing it green fixed 9 reachable CVEs (bumped golang.org/x/crypto to v0.52.0 and the toolchain to go 1.26.4). The gate blocks any reachable-CVE regression from landing.

🐛 Fixed

• Data race in the definition-pattern cache. internal/search's defPatternCache (the compiled-regex memo behind the definition tool) was read and written unsynchronized; concurrent queries could race it. Now guarded by an RWMutex, with a race-detector regression test.

📚 Docs & tooling

New top-level CONTRIBUTING.md and SECURITY.md, a Makefile, a "Compared to other agent code-search tools" table in the README, and a "Personally-namespaced dependencies" section in DEVELOPERS.md documenting the gotreesitter dependency delta and the go.work local-aikit workflow.

Install / upgrade

# Homebrew (macOS/Linux) — ken ships as a cask
brew upgrade --cask ken     # new install: brew install --cask townsendmerino/tap/ken

# Windows (Scoop)
scoop update ken            # new install: scoop bucket add townsendmerino https://github.com/townsendmerino/scoop-bucket; scoop install ken

# Or with Go
go install github.com/townsendmerino/ken/cmd/ken@v1.1.0
go install github.com/townsendmerino/ken/cmd/ken-mcp@v1.1.0

No config changes are required to upgrade. If you run the reranker (KEN_MCP_RERANK=on) and want to keep the full-precision path, set KEN_MCP_RERANK_QUANT=f32.

Full changelog: CHANGELOG.md · compare v1.0.1...v1.1.0

v1.0.1

ken v1.0.1 — faster hybrid search

A patch release: same retrieval quality, ~3× faster hybrid search. No API changes — mcp.Run, mcp.NewServer, mcp.NewCache, FormatResults, the chunk.Chunker interface, and the MCP wire format are unchanged from 1.0.0, so this is a drop-in upgrade.

~3× faster hybrid search (measured)

The headline comes from a aikit bump (v1.0.0 → v1.4.0) that rewrote the semantic-arm cosine scan (ann.Flat.Query) from a scalar-float64 loop to a SIMD-float32 dot kernel with 8-vectors-per-pass streaming. Benchmarked before/after on the same machine:

• Flat.Query 11.7× faster in isolation (2061 µs → 176 µs over 8 000×256).
• End-to-end hybrid search p50 −66 % — 4.58 ms → 1.56 ms on a ~13 k-chunk corpus. The scan is O(N) in chunks, so the win grows with corpus size (it's invisible on tiny repos where search is already sub-millisecond, large on real ones).
• Indexing time unchanged — the bump didn't touch the index path.

Quality is provably untouched: recall@10 was re-verified identical (0.967 NL / 0.995 symbol), and embedding parity holds (golden cosine ≥ 1 − 1e-5 vs the Python reference). The neural reranker is unchanged too (the encoder vectorization in this aikit range targets the int8 path; ken's default reranker runs f32).

Also in this release

• Deserializer fuzzing. FuzzDeserializeIndex and FuzzDecodeRerankCache validate the hand-written adversarial-input defenses in the KEN1 / KNRC binary parsers — the index parser is real attack surface, since ken-mcp auto-loads <repo>/.ken/index.bin from shallow-cloned remote repos. 2.6M executions, zero crashers.
• Model-download fix. ken download-model no longer mistakes a leftover Git-LFS / HF-hub pointer stub (or a broken symlink / truncated file) for a real model. The "already present" check now validates file size, so a stubbed model gets re-downloaded instead of silently failing to load later.
• Robustness from the aikit bump on exactly the paths ken runs: a safetensors mmap-lifetime guardrail and two fuzz-fixed untrusted-tensor crashes in embed, plus bm25 / chunk indexing-pipeline fuzzing.
• Docs accuracy sweep. A full pass aligned the documentation with the post-1.0 / post-extraction reality (package locations, the 10-tool MCP surface, 13 languages, the mcp.Run library example, regenerated third-party licenses, and a current-state ARCHITECTURE.md).

Upgrade

brew upgrade --cask ken      # or: scoop update ken

Or grab a binary below, or go install github.com/townsendmerino/ken/cmd/ken-mcp@v1.0.1. Full detail in CHANGELOG.md; benchmark methodology in docs/PERF-expectations.md.

v1.0.0

ken v1.0.0 — code search for agents, in one binary

ken is a hybrid code-search engine for AI agents: BM25 lexical + Model2Vec semantic embeddings + reciprocal-rank fusion + a code-aware ranking pipeline, served over MCP. It is a faithful Go port of MinishLab/semble — the retrieval algorithm is ported verbatim and validated against the Python reference — packaged as a single static, pure-Go, no-cgo binary: no Python, no GPU, no vector DB, no API keys, air-gapped friendly.

1.0 means two things: the public API surface is frozen (mcp.Run, mcp.NewServer, mcp.NewCache, FormatResults, the chunk.Chunker interface, and the typed JSON-output structs), and the retrieval quality is measured, reproducible, and at its ceiling for this corpus class — every headline number below has an in-tree reproduction harness.

The numbers (all reproducible — see docs/BENCH.md)

• ~97% recall@10 in the default (hybrid) mode — 0.967 NL / 0.995 symbol on semble's 1,251-query, 63-repo benchmark — at ~46× fewer agent tokens than grep + Read for NL queries. grep still wins exhaustive enumeration (~99.9%); ken's job is "find the chunk that answers this," at 1–2 orders of magnitude lower token cost.
• NDCG@10 0.842 vs semble's published 0.854 — the verbatim-port validation, with the semantic-only arms matching within 0.003.
• Opt-in neural reranker: +0.165 NDCG@10 on CoIR — a CodeRankEmbed transformer running entirely in pure Go (hand-written ARM64 NEON assembly, optional int8 quantization, disk-persisted embedding cache).
• At 280K-file corpus scale, grep+Read needs ~16M tokens per NL query (past any context window); ken answers in ~1,300.

Highlights

Zero-setup onboarding — new installs land on the good path

ken-mcp now auto-fetches the embedding model (~60 MB) in the background on first run: it serves BM25 immediately, then transparently upgrades to hybrid (~0.83 → ~0.97 recall@10) when the model lands. No flags, no setup step, stderr-only progress — the JSON-RPC stream stays clean. (KEN_MCP_AUTO_FETCH=0 restores warn-and-downgrade.)

Structural navigation — nine MCP tools, 13 languages

Beyond ranked search (search, find_related), ken builds a structural index from its tree-sitter parse and answers structural questions exactly, by lookup: definition, references, callers, outline, symbols — plus status and recently_changed. Honest framing baked into the tool descriptions: name-resolved, not type-resolved (for type-level call hierarchy, use an LSP). The callers edge data ships with a published precision sample (100% on 400 edges across 8 languages). Languages: Python, Go, TypeScript, JavaScript, Java, Rust, C, C++, C#, PHP, Ruby, Kotlin, Dart.

Retrieval quality, measured the hard way

• Structural enrichment (default-on): every chunk from a supported language is prefixed with an AST-derived label (# func: NAME | calls: A, B | raises: X) before indexing — +0.02 NDCG@10 on leak-free benchmarks, pure Go, no model, KEN_ENRICH=off to disable.
• The recall numbers come from a decomposition harness (internal/search/recall_decomp_test.go) that separates candidate-generation loss from ranking loss — the same harness that caught our own docs misreporting the BM25-only fallback (~0.84) as ken's recall. The corrected, reproducible story is in docs/BENCH.md.

An index that keeps up

• Watch mode by default: ken index stays alive and re-publishes an atomic snapshot ~2s after any file change; ken-mcp always watches, so agents see their own edits.
• Pre-built indices: serialize an index into your binary (mcp.Run + //go:embed) for instant-start embedded corpora; ken-mcp auto-loads <repo>/.ken/index.bin.
• Database schema indexing: point ken at Postgres/MySQL/MariaDB/SQLite and search your schema + migration history alongside code (reindex_db).

Drop-in for semble

Same search / find_related tool schemas, same markdown wire format. If your agent already uses semble, swap the command: path and nothing else changes.

Runs everywhere

macOS, Linux, Windows (amd64 + arm64). brew install --cask townsendmerino/tap/ken, scoop install ken, direct download, or go install. Single static binaries; slim builds ~23 MB (ken) / ~40 MB (ken-mcp).

Try it in 60 seconds

brew install --cask townsendmerino/tap/ken   # or scoop / download / go install
claude mcp add ken -s user -- $(which ken-mcp)
# ask your agent: "where do we handle retry backoff?" — ken auto-fetches the model on first run

Or try the flagship demo — the Go standard library, pre-indexed, model baked in, zero config: ken-demo-go-stdlib. Every Go developer knows this corpus by heart — verify the answers yourself, then reproduce against your own $GOROOT/src in 30 seconds (demos/go-stdlib/README.md). Supporting demos: kubernetes (90K chunks, scale) and postgres (treesitter on C).

Honest limits

• Exhaustive enumeration belongs to grep. Refactors and pre-rename audits need 100% literal recall; ken optimizes relevance per token, not completeness.
• Structural tools are tree-sitter-grade. Name resolution, ranked candidates — not a compiler. Same-spelled symbols collapse; type-level questions need an LSP.
• The neural reranker is opt-in (--mode=hybrid-rerank / KEN_MCP_RERANK=on): it buys NDCG at real latency cost on first contact with a repo (the embedding cache persists to disk and is fast thereafter).

Provenance & thanks

ken stands on semble and the potion-code-16M model by MinishLab, and CodeRankEmbed by Nomic AI / CoRNStack for the reranker. Tree-sitter parsing via gotreesitter; algorithm packages live in aikit (pinned at its own 1.0). Everything runs in pure Go — including the transformer.

Full change history: CHANGELOG.md. Benchmarks and methodology: docs/BENCH.md.

v0.10.1

Changelog

Features

• 43e93df: feat(release): publish Homebrew cask + Scoop manifest (brew/scoop install) (@townsendmerino)

v0.10.0

v0.10.0 — C# · automatic model onboarding · Windows

Three headline additions — plus a measurement correction that's the most important thing in this release.

Highlights

• 🪟 Windows binaries. ken and ken-mcp now ship for Windows (amd64 + arm64) alongside macOS and Linux — pure-Go single static binaries, .zip archives.
• ⬇️ ken-mcp auto-fetches the embedding model on first run. A fresh ken-mcp with no model now downloads it in the background (~60 MB, pure-Go, no Python) and upgrades to hybrid automatically — new installs land on the high-recall path with zero setup. KEN_MCP_AUTO_FETCH=0 to opt out. (ADR-037)
• #️⃣ C# is the 13th language. gotreesitter v0.20.2 bounded the namespace-recovery recursion that used to OOM ken's indexer on real C#, so .cs files now get full structural extraction + Arm B enrichment.

The measurement correction (read this one)

Auditing recall for 1.0, we found the widely-quoted "82–91% recall@10" was the BM25-only fallback — the mode ken runs in when no embedding model is installed. The shipped default (hybrid) mode measures ~97% recall@10 (0.967 NL / 0.995 symbol on semble's 1,251-query benchmark), at ~46× fewer agent tokens than grep+Read (4,120 vs 189,773 median on NL queries).

That reframes the product story: ken isn't "82% and hope" — it's near-grep recall at 1–2 orders of magnitude lower token cost, if you're on hybrid. Which is exactly why auto-fetch is in this release — the only users on the 82% path were the ones who hadn't installed the model, and now that's automatic. Every number is backed by a reproducible decomposition harness (internal/search/recall_decomp_test.go), and the README / benchmark docs were corrected throughout.

Also in this release

• Phase 0 structural call-graph substrate — per-call-site records + span fields on every symbol; groundwork for resolved function-level callers / impact (no tool-surface change yet).
• Crash fix — a guard against a gotreesitter stack overflow on oversized (64 KiB+) table-driven files that could take down ken index.
• Docs overhaul — README trimmed 711 → 184 lines with the recall headline up front; working docs moved to docs/internal/; a new docs/db-indexing.md.

Install

go install github.com/townsendmerino/ken/cmd/ken@v0.10.0
go install github.com/townsendmerino/ken/cmd/ken-mcp@v0.10.0

Or grab a pre-built binary below — .tar.gz for macOS/Linux, .zip for Windows (amd64/arm64). Point your agent at ken-mcp; it fetches the embedding model on first run.

Full notes: CHANGELOG.md · compare v0.9.1...v0.10.0

v0.9.1

Language coverage + upstream-bug diagnostics. Two new structural-extractor languages ship (Kotlin · Dart, taking total coverage to twelve); two languages that were in scope (C# · Swift) get parked behind diagnostic memos ready to file upstream at gotreesitter. A new docs/add-a-language.md walkthrough captures the end-to-end process. No API changes; no behavior change for any existing language.

Highlights

• Kotlin extractor (.kt / .kts). Dogfooded against square/okhttp: 537 files indexed in ~1 s; 5,017 functions (4,816 methods) + 716 classes. Top calls are real okhttp-builder vocabulary (build / Builder / newCall / execute / url), not stdlib noise.
• Dart extractor (.dart). Three coupling points wired in one go — aikit/chunk/treesitter adds the chunker dispatch row, .goreleaser.yml adds grammar_subset_dart so release binaries embed the grammar, internal/structural registers the extractor. Drift guard stays green.
  • Cross-corpus parse-health survey (scripts/dart_survey.go): 74 % / 94 % / 72 % clean root on dart-lang/web / dart-lang/dart_style / flutter/samples.
  • dart_style dogfood: 80 files, 1,565 functions, 143 classes. Top calls are domain vocab (format / pushIndent / popIndent / space / State).
  • flutter/samples dogfood: top calls are real Flutter widget vocabulary — Text / Center / Scaffold / AppBar / Padding / Column / MaterialApp / pumpWidget / runApp.
• C# parked, root-caused. docs/csharp-oom-root-cause.md documents the bug: an unbounded recursion in gotreesitter's normalizeCSharpRecoveredNamespaces — the per-call csharpMaxNamespaceRecoveries = 32 cap bounds breadth in one frame, but each parseWithSnippetParser sub-parse re-enters the recovery pass with a fresh counter, so depth is unbounded. 65-byte minimal reproducer allocates 9M+ objects / 3 GB Go heap in ~3 s. Memo includes goroutine stack showing 5 nested recursions on the same source range, an alloc_objects pprof profile, three suggested fix directions, and a regression test. Three reproducer scripts in tree (csharp_oom_diag.go / csharp_bisect.go / csharp_pprof.go).
• Swift parked, root-caused. docs/swift-parse-root-cause.md documents the bug: the gotreesitter Swift grammar's line-comment lexer fails on common English words. A 35-byte file //\n// software\n\nclass Foo {} already parses to root=ERROR. Cross-corpus survey: 0 % / 2 % / 8 % / 35 % clean-parse rates on Alamofire / swift-nio / swift-collections / Defaults — universally broken on shipping code (every MIT-license-headered file fails).
• Extractors stay in tree for both C# and Swift behind csharp and swift build tags. Re-enabling each is a two-line registration change once the upstream grammar fixes land.
• docs/add-a-language.md — step-by-step walkthrough for new structural extractors: AST probing via KEN_DEBUG_AST=1 KEN_DEBUG_LANG=<grammar> (with new KEN_DEBUG_AST_DEPTH knob), writing the extractor, registering in the maps, fixture tests, dogfood validation, precision-sample check. Documents the field-name-dropping fallback pattern (Rust / Kotlin / Dart).
• gotreesitter v0.20.0-rc2 → v0.20.0-rc3 in both ken and aikit go.mod. The C# OOM was re-tested against rc3 — still OOMs the same way (rc3's GLR fork-reduction targeted the C grammar, not C#).

Backwards compatibility

• No behavior change for any existing language. Kotlin + Dart are pure adds.
• No API additions or removals. No new MCP tools, no library surface changes.
• Slim-binary drift guard (TestSubsetTagsMatchKenToTreeSitter) stays green — the three Dart wirepoints are in sync.

Full CHANGELOG entry has the complete per-area breakdown including the C# + Swift memos.

v0.9.0

The 1.0 release candidate. Feature-complete; the seven-item 1.0 ship-list closes, Stage 8 (structural navigation + Arm B chunk enrichment) closes, and the startup + query-latency perf campaign closes.

Highlights

• Five new MCP tools for tree-sitter-grade structural navigation, shipping across 10 languages (Python · Go · TypeScript · JavaScript · Java · Rust · C · C++ · PHP · Ruby): definition · references · callers · outline · symbols. Stage 8 Gate 2 precision sample: 100 % on 400 edges across 8 languages.
• Arm B chunk-level enrichment (# func: NAME | calls: A, B | raises: X prepended to every chunk's text before BM25 + embedding). Pure-Go, no extra model. Default-on; opt out with KEN_ENRICH=off. Measured +0.0208 NDCG@10 hybrid on csn-python-nl-stripped (N=500) and +0.0321 on CoSQA dev. ADR-035.
• Three new top-level tools: callers(name), recently_changed(n) (git log over the working tree), and ken status (build identity + index health + token savings). All three exposed as both CLI and MCP.
• JSON output mode on search / find_related / definition / references / callers / outline / symbols / status. Typed response structs in mcp/json_responses.go are the 1.0-stable wire format.
• Search filters on search: languages / path_contains / exclude_path_contains with over-fetch + post-filter + ratio-in-header response.
• Cold start dropped 55–79 % via M2 (lazy rerank model load, −491 ms ken-mcp startup) + M4 (parallel structural.Build, 3.5–4.5×). Warm-search p50 unchanged (already sub-millisecond). ADR-036.
• Slim release binaries via gotreesitter grammar_subset build tags — ken-mcp 52 → 38 MB, ken 36 → 22 MB. ADR-033.
• Reusable packages extracted into a separate module at github.com/townsendmerino/aikit — topk · ann · bm25 · embed · encoder (was coderank) · chunk (+ regex/markdown/treesitter). ADR-034. Encoder golden cosine = 1.000000 preserved end-to-end.
• First-class user-facing docs: USERS.md and DEVELOPERS.md.

Notes

• Breaking change for the public chunk path: was github.com/townsendmerino/ken/chunk (added in ADR-032, never released); now github.com/townsendmerino/aikit/chunk. GitHub code search confirms zero downstream consumers — hard break, no shim.
• ken-mcp auto-loads <repo>/.ken/index.bin when present (closes #32). Mode/chunker mismatch is a hard startup failure; corrupt/missing falls back to a live build with a stderr warning.

Full CHANGELOG entry has the complete per-area breakdown.

demos/v0.2.0 — flagship go-stdlib + refreshed kubernetes + postgres

demos/v0.2.0 — adds the Go stdlib flagship; refreshes kubernetes + postgres to upstream's latest stable majors.

Same single-static-binary pattern as demos/v0.1.0 — pre-built search index + Model2Vec model baked in via //go:embed, no runtime dependencies, no network at startup. Built against ken commit <COMMIT> (ken main post-v0.9.1 + the demo's own commit).

Three downloadable demos

binary	corpus	chunker	mode	chunks	download
ken-demo-go-stdlib ⭐	Go 1.26.3 stdlib ($GOROOT/src minus cmd/, */testdata/*)	regex	hybrid	35,708	~128 MB
ken-demo-kubernetes	kubernetes v1.36.0 (vendor + generated excluded)	regex	hybrid	90,063	~192 MB
ken-demo-postgres	postgres REL_18_0 (doc + test fixtures excluded)	treesitter	hybrid	69,601	~177 MB

Per platform: darwin/arm64, darwin/amd64, linux/amd64, linux/arm64. Static, no cgo, no dynamic dependencies. Verify your download against SHA256SUMS.

The flagship: ken-demo-go-stdlib

The Go stdlib is the corpus every Go developer already has on disk and knows cold. Every demo answer is verifiable instantly ("yes, that's exactly right"), and the audience can reproduce the entire demo against their own $GOROOT/src in 30 seconds:

mkdir -p /tmp/go-stdlib-curated
rsync -a --delete \
  --exclude='cmd/' --exclude='testdata/' --exclude='*/testdata/' --exclude='vendor/' \
  "$(go env GOROOT)/src/" /tmp/go-stdlib-curated/
KEN_MCP_DEFAULT_REPO=/tmp/go-stdlib-curated ken-mcp

Then ask things like:

• "where is goroutine scheduling decided" → runtime/proc.go (single targeted hit vs 230 grep hits across 58 files)
• "how does context cancellation reach an in-flight HTTP request" → net/http/transport.go::prepareTransportCancel (vs 345 grep hits across 22 files)
• "where do goroutines block on a full channel" → runtime/chan.go (vs 1,103 grep hits across 131 files)

The 14 vetted demo artifacts (7 semantic-bridging queries, 4 structural-tool lookups, 3 head-to-head-vs-grep comparisons) are documented at demos/go-stdlib/QUERIES.md with reproducible harnesses at scripts/stdlib_demo_vet.go and scripts/stdlib_phase1_close.go.

kubernetes + postgres refreshed

Both demos refreshed against newer upstream:

• kubernetes: v1.31.0 → v1.36.0 (5 minor versions of upstream drift). Chunk count: 59,795 → 90,063 (k8s grew).
• postgres: REL_17_0 → REL_18_0 (1 major version of upstream drift). Chunk count: 64,506 → 69,601.

Both also pick up post-v0.1.0 ken improvements: slim-binary subset tags (ADR-033), ADR-024 prebuilt-index load polish, and the v0.8.x perf-campaign + v0.9.x post-1.0-RC wins.

Note on transcript drift. The captured agent transcripts under demos/transcripts/ are pre-v0.2.0 evidence (frozen against demos/v0.1.0's k8s v1.31.0 + postgres REL_17_0). Specific path:line citations in those transcripts may not resolve to the same lines (or files, for refactored code) when re-run against the v0.2.0 binaries. The query types still work; specific cited paths may have drifted. See demos/transcripts/README.md for the full provenance note + the six question prompts if you want to re-run them against v0.2.0.

Install

# 1. Download the archive for your platform from this release page.
# 2. Verify the SHA256:
shasum -a 256 -c <(grep ken-demo-go-stdlib-darwin-arm64 SHA256SUMS)

# 3. Extract:
tar -xzf ken-demo-go-stdlib-darwin-arm64.tar.gz

# 4. (Optional) drop on $PATH:
mv ken-demo-go-stdlib /usr/local/bin/

# 5. Register with your MCP client. Claude Code:
claude mcp add ken-demo-go-stdlib -s user -- /usr/local/bin/ken-demo-go-stdlib

Resource usage on Apple M1 Pro: ~2-3 s startup, sub-second to tens-of-ms queries, ~1-1.5 GB resident. Allow ~2 GB free RAM per running demo.

Links

• ken: https://github.com/townsendmerino/ken
• go-stdlib demo source + vetted queries: demos/go-stdlib/
• kubernetes demo source: demos/kubernetes/
• postgres demo source: demos/postgres/
• Cross-repo build script: scripts/build_demo_binaries.sh
• Previous demos release: demos/v0.1.0

v0.8.8

Changelog

Features

• 51fbb47: feat(ken-mcp): auto-load pre-built index /.ken/index.bin (cold-start fix) (@townsendmerino)
• d8cd0cc: feat(treesitter): per-reason fallback counters + ken perf index JSON surface (@townsendmerino)

Others

• c3a646a: perf(db): parallelize mysqlAppendSamples + ADR-031 (v0.8.8); Postgres deferred-with-trigger (@townsendmerino)