diffctx 1.15.0__tar.gz → 1.16.0__tar.gz

{diffctx-1.15.0 → diffctx-1.16.0}/CHANGELOG.md

@@ -7,6 +7,524 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.16.0] - 2026-09-16
+
+### Added
+
+- **A FAQ and a benchmarks page** (#151): `docs/product/faq.md` answers the
+  recurring critiques (heuristic or oracle, the `tree-sitter` extra that no
+  longer exists, whose tokens `--budget` counts, MCP versus a prompt builder,
+  monorepo limits, the raw diff, secrets) and `BENCHMARKS.md` carries every
+  published number with what it was measured on and how to reproduce it.
+- **A command-line reference page** (#240): `docs/product/cli.md` lists every
+  flag with its default and meaning, rendered from the parsers by
+  `scripts/update_cli_reference.py` and pinned by a test so it cannot drift
+  from `diffctx --help`. Linked from the site's nav, `llms.txt` and the
+  README.
+- **Every changed file gets a witness before any file gets a second one**
+  (#263). Selection now opens with an evidence floor: one representation per
+  changed file — the same fragment the relevance pass would place, its
+  stand-in when that does not fit, a clipped head of the change when nothing
+  does — ordered by change class (hand-written content before mechanical
+  version/tag bumps) and then by path. Relevance and density compete only
+  for what is left. A range of nine one-line image-tag bumps plus four
+  rewritten manifests at `--budget 4000` now keeps all thirteen; before, the
+  four manifests were dropped in favour of the bumps. A file that still gets
+  nothing marks the artifact `coverage.status: degraded` with
+  `evidence_budget_exceeded`.
+- **The rendered document is what `--budget` bounds** (#259). Every
+  renderer — JSON, YAML, Markdown, text, the CLI and the Python `to_*`
+  functions — counts its own output and drops context fragments from the
+  tail (a changed fragment only when no context is left) until it fits,
+  noting `selection_budget_exceeded` in coverage. The engine's envelope
+  estimate still shapes what selection admits, but it no longer decides
+  whether the artifact honours the cap.
+- **The artifact inventories every changed file and says which ones it
+  left out** (#263). `changes` carries one row per changed file — its
+  `class` (`content`, `unknown`, `mechanical`: one-line version/tag/digest
+  edits of the kind an image updater writes, `generated`), the `reason`, and
+  `represented`, false when no fragment of the file is in the output. JSON,
+  YAML, the Python dict, Markdown and text all say it; `locate`'s coverage
+  lists `unrepresented_changed_files`. An incomplete context is no longer
+  indistinguishable from a complete one on any surface.
+- **The artifact carries the commit messages of the range, whole.**
+  `commit_messages` lists every message — subject and body, up to 20
+  commits, 2 000 characters each — newest first; Markdown and text render
+  them instead of the subject of whichever commit happened to be last, and
+  every message feeds the query expansion, not only the head's subject.
+  `commit_message` stays the head's subject for existing readers. The list is
+  bounded by the budget — every subject, bodies newest-first while they fit a
+  tenth of it — and, like the inventory rows, charged before selection.
+- **One artifact, `diffctx.context.v1`, on every surface.** JSON and YAML
+  output open with `schema: diffctx.context.v1`; the document is generated
+  from the engine's type and pinned as `schemas/diffctx.context.v1.json`
+  (JSON Schema 2020-12, a test regenerates and compares it). The Python dict
+  is that same serialization — the hand-written `set_item` copy of the
+  shape, the one that never ran on the CLI path, is gone (#229).
+- **Every run records what produced it.** JSON and YAML output (and the
+  Python dict) carry a `provenance` block — `diffctx.provenance.v1`: engine
+  version, the input revisions as object ids, the resolved effective
+  configuration (`diffctx.effective_config.v1`: every parameter and every
+  `DIFFCTX_*` override that shaped the selection) and its 64-bit hash, the
+  selection parameters actually used (budget, tau, gate). The full record —
+  every parameter, the tokenizer, the resource caps, ~500 tokens — is
+  opt-in with `DIFFCTX_PROVENANCE=full`. Two runs that differ can now say
+  what differed between them.
+- **`DIFFCTX_EVAL_STRICT=1`** refuses to start when the environment carries a
+  `DIFFCTX_*` name the effective configuration does not know — an evaluation
+  row shaped by an undeclared knob is a number nobody can reproduce.
+- **`DIFFCTX_TOKEN_SAFETY_FACTOR`** (≥ 1.0, default 1.0) scales every token
+  count for consumers whose model tokenizes denser than `o200k_base`;
+  `--budget N` stays "N o200k_base accounting tokens" and the factor is in
+  provenance. No model-specific default is shipped.
+- **A run that hits a limit says so instead of failing.** `--timeout` is
+  cooperative now: the phase it interrupts stops at its next bounded unit (a
+  file, an edge builder, a diffusion batch) and the run renders what it has,
+  with a `coverage` block — `status: partial`, `limit_reasons`, and the
+  resources consumed — on JSON, YAML, Markdown, text, the Python dict and
+  `locate`'s coverage. The same vocabulary covers the new memory caps:
+  `DIFFCTX_MAX_EDGE_CONTRIBUTIONS` (20M, counted before deduplication — the
+  number that owned 11 GB on a 10k-module monorepo, #196),
+  `DIFFCTX_MAX_SOURCE_BYTES` (256 MB of parsed source, never the changed
+  files themselves), `DIFFCTX_MAX_CANDIDATE_FILES` (200k) and
+  `DIFFCTX_MAX_NEEDS` (4k: every candidate is scored against every
+  information need mined from the diff, and a repository-sized diff produced
+  a need set that made selection take 413 s on this repository's own
+  history — 6 s under the cap). The caps are part of the effective
+  configuration and its hash.
+
+### Security
+
+- **Credential-shaped strings are redacted on every read surface** (#147).
+  A last pass over the diff artifact (fragments, commit messages), the
+  `--with-raw-diff` bundle, the MCP fetch and glob readers and tree mode
+  replaces strings matching a small set of high-confidence shapes — AWS
+  access key ids, GitHub, Slack, Stripe, Google and OpenAI keys, JWTs, PEM
+  private-key blocks — with `[REDACTED:<category>]`; the artifact carries a
+  `redactions` block (count, categories) and `sanitization_redaction` among
+  its coverage limit reasons. Defence in depth, not a guarantee: only shapes
+  that cannot be anything else are matched, and SECURITY.md says what is not
+  caught. The withhold policy (secret-by-name files, ignore rules) is
+  unchanged and remains the mechanism to rely on.
+- **A `diff_ref` could turn the read-only MCP fetch into a file write.** With
+  `fragment_ids` set the engine never sees `diff_ref`, and `fetch_fragments`
+  passed whatever followed `..` straight to `git show <rev>:<path>` — so
+  `HEAD..--output=/tmp/x` wrote a file. A rev starting with `-` is refused and
+  `git show` runs with `--end-of-options`.
+- **An explicit file argument bypassed the secret-path floor.** The tree walk
+  applies `is_secret_path` to every entry, but `diffctx id_rsa` and
+  `diffctx '**/*'` fed the expanded paths straight to the reader; the same
+  policy now applies to them, with a one-line notice of how many were
+  withheld.
+- **The MCP allow-list is checked before the filesystem is.** `validate_repo_path`
+  probed `is_dir()` and walked up to `.git` before consulting
+  `DIFFCTX_ALLOWED_PATHS`, so a refused caller learned whether a path existed;
+  the order now matches what SECURITY.md promised.
+- **The scratch git dir for non-repository reads is created exclusively.** Its
+  name was `temp_dir/diffctx-scratch-git-<pid>-<n>`, guessable, and `git init`
+  adopts an existing `.git` — a pre-planted one with its own `excludesFile`
+  decided what the reader called ignored. Created with `create_dir` (0700), a
+  collision moves to the next name.
+- **A `.diffctx/ignore` policy that could not be read failed open.** When
+  `ls-files` or a pattern file read failed, the lookup reported "no patterns
+  declared" and a subsequent `check-ignore` failure landed on the fail-open
+  branch. Discovery failure now fails closed; a bare repository, which cannot
+  carry a policy, is the one exception.
+
+- **An ignored directory's contents were readable through the MCP glob**
+  (regression introduced with #228, caught the same day). `withheld_paths`
+  reused the engine's *attribution* lookup, which deliberately drops
+  ancestor-inherited exclusions — a tracked file under a directory that
+  `--no-index` reports excluded is not really ignored (#153). For the diff,
+  whose paths are tracked by construction, that is right; for a reader walking
+  the working tree it is exactly wrong, because `.venv/x.py` is ignored *by*
+  the `.venv/` rule on its parent. `git check-ignore` called those paths
+  ignored while the engine called them servable, so `get_file_context` and
+  `diffctx_context` would return the contents of `.venv/`, `dist/`, `target/`
+  and any repository's `secrets/`. Fixed with a lookup that keeps
+  ancestor-inherited matches; `.git/` is withheld outright — it is not
+  gitignored at all, and `.git/config` carries the remote URL.
+- **The glob reader applies the tree-mode noise filter again**: unifying it
+  onto the engine alone (#228) also dropped `node_modules/`, `target/` and
+  lock files from `get_file_context`, contradicting the tool's own
+  description. Both filters now apply there — the noise spec `get_tree_map`
+  uses, and the engine as the security floor. `fetch_fragments` keeps the
+  engine alone, which is what makes a ranked `build/gen.py` fetchable.
+
+- **One secret-path policy for every surface** (#227): tree mode kept its own,
+  shorter list, so `.netrc`, `credentials`, `_netrc`, `.npmrc`, `.pypirc`,
+  `id_*_sk`, `*.ppk`, `*.p8` and `*.asc` — all withheld by diff mode — were
+  printed in full by `diffctx .`. Tree mode now asks the engine
+  (`_diffctx.is_secret_path`), unconditionally: `--no-default-ignores` drops
+  the noise filters, never the secret policy, the same contract diff mode has.
+- **The MCP fetch refuses exactly what the engine withholds** (#228). It
+  re-derived admissibility with pathspec, so it served a `.netrc` the
+  selection had refused and refused a `build/gen.py` the selection had
+  ranked. `fragment_ids` and the legacy glob reader now ask the engine
+  (`_diffctx.withheld_paths`: secret by name, or ignored as `git check-ignore`
+  resolves `.gitignore` / `.diffctx/ignore`) in one batched call. Outside a
+  git work tree — the legacy reader accepts any directory — git runs with a
+  scratch `--git-dir`, so `.diffctx/ignore` binds there too.
+
+### Fixed
+
+- **A `---` bundle is every resource it holds, not its first** (#258). The
+  Kubernetes edge builder now reads one view per YAML document, so a
+  Service in the third document is indexed as a Service, its selector meets
+  the Deployment in the second, and two Deployments' labels no longer
+  collapse into one last-wins map. A generated manifest keeps its
+  `apiVersion:`/`kind:`/`metadata:` pairs through the generated-file cut,
+  which used to drop them as the shortest fragments and with them the
+  detection that made the file a manifest at all.
+- **Scala imports, packages and inheritance come off the parse tree**
+  (#243). `tree-sitter-scala` already parsed every Scala file for
+  fragmentation; the edge layer re-read the text with a regex on its fifth
+  patch. `facts::scala` now walks `import_declaration` (braces, `=>` and
+  `as` renames, `_`/`*`/`given` wildcards, multi-line groups),
+  `package_clause` chains and `extends_clause` types; the regex reader
+  stays as the fallback for text that does not parse cleanly, and the two
+  are held to agree on every shape the tests name. An import inside a
+  block comment is no longer an import.
+- **The compose `context:` and CI→`package.json` channels revived on
+  2026-09-02 were dead on arrival.** Both built their path reference from the
+  fragment's absolute path, while the fragment index is keyed repo-relative,
+  so nothing matched — and the CI walk, climbing to `/`, degraded to the bare
+  name and linked every `package.json` again. Both resolve in the index's own
+  key space now, the CI walk matches one exact path per level, and each
+  builder has a test with absolute paths and a repo root, the shape
+  production uses. Q-class: one overflow candidate moves on the bitcheck
+  fixture (its workflows run `npm`), nothing in the selection.
+- **A plain directory whose scratch `git init` failed withheld every file**:
+  "no git dir" was read as "policy unreadable" and failed closed. It has no
+  policy to read; gitignore filtering is skipped there, secret-by-name still
+  applies.
+- **A blank line after `selector:` let sibling keys back into the label
+  block**; the indentation bar is taken from the first line carrying a key.
+- **`envelope_tokens` was computed before the lockfile/ignored lists it
+  summarises were set** on the empty-selection path.
+- **`TestSetReport.n` reports instances attempted**, not survivors, so a cell
+  that failed on every instance no longer reads as "ran fine, recall 0".
+- **The dev-loop harness honours `DIFFCTX_YAML_MIN_SCORE`** like the CI gate,
+  and `compare` / `aggregate-seeds` keep their exit code when run as scripts.
+
+- **`stratified-analysis` returned no rows at all**: the 2026-09-01 fix that
+  taught it the multi-budget checkpoint layout left the `rows.append` under a
+  `continue` and the `return` inside the loop, so the first cell's rows were
+  never appended and every later cell was never visited. Sonar's
+  unreachable-code rule caught it; a test now feeds it two cells in both
+  layouts and expects every row back — it fails on the previous code.
+- **The demo names what it left out.** Its output panel showed the selection
+  and nothing else; the real artifact lists omitted changed files and locate
+  mode reports overflow. The toy now prints which fragments did not fit the
+  budget and how many fell below τ, and a direct click on stage 5 renders
+  the selection instead of "0 tokens".
+
+- **Edge builders that linked the wrong thing, or everything.** A compose
+  file's `context: .` stripped to `.` and `path.contains(".")` matched every
+  file with an extension — the compose file linked to the whole universe at
+  naming weight; `.` now means the compose file's own directory and a named
+  context takes the path channel's ambiguity bar. A Service's selector regex
+  kept consuming less-indented sibling keys (`type: ClusterIP`) and made each
+  a required label, so kubectl-ordered Services never matched their workload;
+  label blocks now end where their indentation does. `envFrom:
+  configMapRef/secretRef` — the standard way to inject a whole map — was not
+  a recognised reference. A shared base image linked every workload pairwise
+  at naming weight; the image channel takes the same eight-file bar as every
+  other reference channel and never links a manifest to itself. A CI file
+  mentioning `npm` linked to every `package.json` in the repository; it links
+  to the nearest one above it. A bare-name reference (`config.yaml`,
+  `main.go`) linked to the first fragment of the first same-named file; it
+  links each such file's representative, abstaining above the bar, and a
+  module directory (`import Database`) still resolves as a path. Cargo
+  entry-point edges landed on the last fragment of the target file instead
+  of its representative, and Ansible role siblings were emitted
+  fragment × fragment (22k emissions for two task files) — now one edge per
+  file pair through representatives, capped like directory siblings. All
+  Q-class; corpus 2902/2902, no baseline movement.
+- **The eval harness's multi-budget checkpoints were invisible to
+  `stratified-analysis` and `backfill-checkpoints`**: both globbed only the
+  flat `<set>.checkpoint.jsonl`, so every diffctx cell of a full sweep
+  contributed zero rows. One discovery helper serves all three readers.
+  `--repos-dir` now relocates the bare-clone cache too (it read an
+  import-time constant and sent clones to the home directory while the disk
+  probe measured the flag's volume); `run-final` names its checkpoint after
+  the ablation parameters so cells sharing an `--out` stop resuming each
+  other's rows; `clone_fail`/`error` rows are re-evaluated on resume instead
+  of being checkpointed as verdicts; infrastructure failures are excluded
+  from the headline recall as `apply_gold_patch` always documented; per-depth
+  reports no longer pool under one name; `compare` and `aggregate-seeds`
+  exit non-zero on an unusable input.
+
+- **A filename containing a newline desynchronised the cat-file batch**: the
+  request stream is line-delimited, so one such path became two requests and
+  every later file was served the previous request's leftover body. Paths with
+  control characters go through `git show` on argv instead.
+- **The native binary without `--diff` ran a bare `git diff`** (index vs
+  worktree, staged edits invisible) while the pipeline read the same absence
+  as "vs HEAD"; both now mean HEAD, and git/environment failures exit 3 as the
+  README and the Python CLI already promised (was 1).
+- **`diffctx . | head` exits 141 in tree and pack mode**, as documented; the
+  writer swallowed the broken pipe and the run exited 0.
+- **`-o FILE` no longer downgrades the output to mode 0600** — the temp file
+  takes the mode the umask gives a new file before it replaces the target.
+- **A fragment id past the end of its file is refused**, not silently clamped
+  to the last line.
+- **The discovery walk fallback used the attribution ignore lookup**, so an
+  ignored directory's contents entered the universe when `ls-files` failed.
+- **`--alpha` was documented backwards**: it is PPR's continuation
+  probability, so a higher value sends relevance further from the change.
+  README, CLI help and the Action docs said "tighter".
+- **`--budget 0` was described four incompatible ways**; every surface now
+  says what happens — no fragments, changed files listed as omitted.
+- **Three CI gates could not fail**: the sdist "contains Rust sources" check
+  returned `head`'s exit status, the results-branch push loop exited 0 after
+  three failed pushes, and the radon complexity step returned 0 whatever it
+  found (deleted; the pre-commit xenon hook is the gate). The sensitivity
+  workflow gets pipefail, the Hetzner cleanup no longer cancels itself, the
+  dead v1-artifact heartbeat is gone, and the release bump now patches
+  `CITATION.cff` (the test that asserts it equal to `__version__` would have
+  turned the next release red).
+- **`bitcheck.sh`'s pinned commits are anchored by `bitcheck/<sha>` tags** on
+  both remotes — the history rewrite had left them reachable from nothing.
+- **The corpus harness verifies `auto_garbage`** as SCHEMA.md promised; the
+  injection half existed alone. The pre-commit corpus sample covers every
+  stratum and runs on case edits.
+
+- **`--budget` now covers the whole artifact** (#241). It bounded only the
+  fragments: the commit message and the changed/deleted/renamed/lockfile/
+  ignored path lists rendered for free, and the changed-file list was printed
+  twice — once in full, once again as a "not represented" footer. On an
+  83-file range `--budget 1000` produced 3 150 tokens and `--budget 0`
+  produced 2 464, with the selection dutifully under budget the whole time.
+  The summary is charged before selection starts and printed once, with
+  omitted entries marked in place. A budget too small to hold the summary now
+  yields the summary and no fragments — a changed path is never dropped to fit.
+- **One generated file can no longer take the budget from every other changed
+  file** (#238). Cores that miss the core-budget reservation are swept
+  cheapest-first, and that sweep applied no per-file ceiling — so a changed
+  `records.json`, whose record-sized cores are the cheapest candidates in the
+  run, refilled the whole budget while the files it was deferred behind got
+  nothing. The sweep now runs in two rounds: the ceiling holds in the first,
+  and only what it blocked is replayed in the second, so unclaimed budget
+  still flows back.
+- **The Kubernetes edge builder emitted nothing at all** (#226). Detection ran
+  per fragment and required `apiVersion:` and `kind:` in the same one, but the
+  YAML parser splits a manifest by top-level key — so no fragment of any
+  manifest ever qualified and all six channels (selector→workload, configmap,
+  secret, service, volume, image) were dead. Detection runs on the file, whose
+  text is rebuilt from its fragments by line number, and each edge is anchored
+  on the smallest fragment covering the construct it is about.
+- **The deadline test measured the repository's history, not the deadline.**
+  It asked for `HEAD~20`, which stopped exceeding the ceiling when the history
+  was squashed into epochs; it now runs the root commit to HEAD, the largest
+  diff the repo can produce.
+- **`python -m eval equivalence` could not fail** (#233): the CLI dispatcher
+  discarded each subcommand's return value, so the gate printed
+  "EQUIVALENCE FAILED" and exited 0. Any CI job wired to the documented
+  invocation was decorative.
+
+- **A POSIX filename containing a backslash keeps its name and its own
+  content** (#239). Every path written into output — and the `rev:path` spec
+  handed to `git show` — rewrote `\` to `/`, so with `src\utils.py`
+  (changed) and `src/utils.py` (untouched) both present, the changed file was
+  listed under the other's name and rendered with the other's body. All
+  eight sites now go through `paths.rs`, which rewrites only on Windows.
+- **The corpus harness anchors a pure deletion where git does.** The
+  in-memory diff started a deletion-only hunk one line below git's
+  `@@ -5 +4,0 @@`, so `core_selection_range` — and therefore every
+  deletion-carrying corpus case — scored a selection production never
+  produces. Pinned by a test that compares both sides on the same deletion.
+- **A truncated generated fragment costs what it weighs**: it carried
+  `token_count: 0`, free for the budget while still rendering in full.
+- **`cat-file --batch` stays in sync**: a swallowed record terminator used to
+  shift the stream one byte for every later read, and a child that could not
+  be queried counted as alive and was never restarted.
+- **Naming only files roots the tree at their common parent**, not the
+  current directory, so `.diffctx/ignore` and relative paths resolve where
+  the files live; the wrapper node is named after that root instead of ".".
+- **A failed native import no longer buries the error being handled**: the
+  CLI's git-error handler imported the extension inside the `except` clause.
+- **The quotient-graph registry holds the graphs it keys by `id()`**; a
+  collected graph's recycled id could label the next graph with the wrong
+  node keys.
+- Boltzmann objective: the selection reason is decided after the loop, cores
+  count toward the reported utility, and overlap goes through the shared
+  `IntervalIndex` instead of a fourth hand-written check.
+
+### Changed
+
+- **File-level relations land on one fragment per file, and a change
+  lifts to its file** (#196). An import, a directory sibling, a shared
+  package or crate root, a covering test are relations between files: the
+  Python, Rust and Go builders link the file's representative fragment (the
+  same one every builder names, ties now broken by position rather than by
+  the order a builder happened to hold the fragments in), and `from m import
+  x` / `pkg.Sym` / `Mod::sym` link the fragment that defines the named
+  symbol. In return the ego walk seeds each changed fragment's file
+  representative at the containment discount, so a function added to an
+  existing module still meets the module's importers and its tests. A name
+  used in more than 64 files without importing its definer (`hass`,
+  `config`, `entry`) is vocabulary and no longer fans out to its
+  definitions; qualified calls (`Type::new(`, `pkg.New(`), method calls
+  and definition lines no longer feed the unqualified call channel, which
+  linked every `::new(` to every `fn new` in reach; Go imports come from
+  the import block, not from any quoted line; Python relative imports
+  resolve to the sibling module they name. Same machine, same instances as
+  the issue's table: home-assistant 38.1M → 2.8M python edges, 100 s → 24 s,
+  10.9 → 2.5 GB; polars 35.4M → 0.8M rust edges, 54 s → 4 s, 5.4 → 0.8 GB;
+  kubernetes 14.3M → 4.9M go edges (the rest of that run is parsing).
+  Q-class: 16 corpus cases lift above the threshold, one `gap` case is
+  baselined (`gap_132`: the file lift admits a consumer of a sibling type).
+  Edge-weight profile `v2-2026-09-16`.
+- **One heavy phase for the product and the corpus harness.** From the
+  fragments onward — token counts, cores and their stand-ins, signature
+  variants, seed weights, scoring, information needs — both paths call
+  `pipeline::score_from_fragments`; the harness's own spelling of those
+  steps is gone, and the `DIFFCTX_OBJECTIVE` override, which only the
+  product used to see, is resolved with the mode for every caller (#232).
+- **The compute deadline is no longer a panic, and never an exception.**
+  `ComputeTimeoutError` stays importable but the engine does not raise it;
+  a git subprocess that overruns its share of the timeout is still a
+  `GitError`. The native CLI exits 0 with a partial artifact at the deadline;
+  124 is reserved for the watchdog that fires 30 s later when a phase could
+  not stop. `--timeout 0` is therefore a git failure (exit 3), not an abort.
+
+- **The hero comparison names both baselines.** It measured whole changed
+  files pasted (17.6×) while the headline invites comparison with a raw
+  `git diff` — the question three first-visit probes actually asked. The raw
+  diff of the same commit is 169,809 tokens, so that ratio is 3.9×, and the
+  caption says so next to the number.
+
+- **The `tree-sitter` extra is gone** (`full` = charset-normalizer alone):
+  it shipped seventeen grammar wheels nothing in the package imports — parsing
+  lives in the Rust crate. `uv.lock` shrinks by ~370 lines.
+- **The landing page's copy now matches the tool**: five scoring modes, the
+  τ dial at the shipped 0.05, YAML labelled as the shown (not default)
+  format, α attributed to PPR, the toy's numbers reconciled with the hero
+  measurement and its denominator's generated snapshot named, `llms.txt`
+  naming the one tool that exists.
+
+- **The landing page's headline comparison names its source.** It shipped
+  `48,210 → 6,930 tokens, 7×` with no provenance on the page and none in the
+  repository either; three independent first-visit probes each reached the
+  same verdict — the one number meant to justify adoption could not be checked.
+  It now reads 768,268 → 43,769 (17.6×), measured on
+  home-assistant/core@1d885bd0 (66 files changed) with the command printed
+  beside it, and says plainly that the ratio tracks how much of the changed
+  files is unrelated to the change. A test gates the provenance, not the value.
+
+- **The GIL is released for the last three heavy extension calls** (#245):
+  `build_project_graph` (a full repository walk plus a tree-sitter parse of
+  every file), `resolve_diff_range` (spawns `git`) and `count_tokens`. Held
+  under the GIL these blocked every other thread in the host interpreter for
+  their whole duration, which is precisely the wall-clock a latency column is
+  supposed to attribute to diffctx.
+- **The eval sweep no longer runs 45 duplicate cells** (#233): `depth` reaches
+  the runner only when it is non-negative, but `internal-bm25`, `rrf` and
+  `pit` had no depth excludes, so each ran five byte-identical copies of its
+  cell per test set — half the matrix, about a third of the machine hours. The
+  smoke cell also asserts its own result now instead of printing it, and is
+  handed `HF_TOKEN` so dataset reads are not rate-limited.
+
+- **The eval harness's Python dependencies are a `uv` dependency group**
+  (`uv sync --group eval`), locked in `uv.lock` like everything else.
+  `requirements-eval.txt` + `.lock` — a second resolver with its own bot —
+  are gone; `Dockerfile.eval` exports the group with hashes.
+- `paper/v1` left the tree (it lives at tag `paper-v1-grid`); five
+  never-called statistics helpers and `reset_to_commit` left `eval/`.
+- Test hygiene: locate and pack are pinned to each other's `changed` set
+  (pack used to be compared with itself); the path-jail refusal property
+  runs on every example and registers the legacy tools once; the deadline
+  test requires the ceiling to fire; the panic-profile test reads the
+  release table only; the Rust and Python `.diffctx/ignore` anchorers share
+  one fixture table instead of a "mirrors" comment.
+- **A git subprocess whose output could not be read no longer reports an
+  empty diff.** The pipe reader's failure collapsed into an empty buffer
+  returned as success, so an unreadable `git diff` was indistinguishable from
+  a range with no changes. It is an error now. `is_git_repo` likewise stops
+  answering "not a git repository" when git did not run at all (missing from
+  PATH, permission denied): only git's own "no" is a "no".
+- **The weak stopping threshold never ships without the admission gate.**
+  `tau = 0.05` was calibrated with the per-file naming gate on (#65);
+  `--scoring bm25` has no graph to build a gate from and rode the weak stop
+  anyway, re-admitting exactly the diffuse tail the gate blocks. A scorer that
+  produces no gate — BM25, or `DIFFCTX_FILE_ADMISSION=0` — now uses the
+  pre-gate threshold (0.12) whenever `--tau` is left at its default value
+  (an explicit `--tau 0.05` is indistinguishable from the default and gets the
+  same substitution; any other explicit value is used as given).
+- **A range whose changed-file list is empty still discloses what it
+  withheld**: the third early exit in `resolve_change_set` returned zeroed
+  lock-file, ignored and policy counts it had already computed.
+- **Rust lifetimes no longer break signature extraction.** `'` was a string
+  opener in every language; `fn f<'a>(x: &'a T)` has no closing quote, the
+  scanner swallowed the rest of the line and lost the parameter list, and the
+  stub fell back to two lines cut mid-signature.
+- **`.env` and `.editorconfig` are recognized.** They were registered as
+  extensions, and a dotfile has none, so neither ever entered the candidate
+  universe. A bare lowercase `build` or `workspace` is no longer classified as
+  Bazel — only the capitalized names Bazel actually uses.
+- **Scala imports inside an unbalanced brace group are kept.** The
+  multi-line join consumed up to 32 lines and never re-scanned them, so an
+  `import` in that window vanished; it now stops at the next `import` line.
+  Scala 3 `as` renames split on any whitespace, not the literal single space.
+- **The C-family pairing loop polls the deadline per pair, not per stem
+  bucket** (#210): envoy's 520 files sharing one stem are a single bucket, so
+  the bucket-level poll never fired inside the case it was added for.
+- `scripts/bitcheck.sh` builds the binary it measures. It read whatever
+  `target/release/diffctx` the last `cargo test --release` had left, so a
+  `record`/`check` pair around an unbuilt edit compared one stale binary with
+  itself.
+- The MCP server warns at startup when `DIFFCTX_ALLOWED_PATHS` is unset, so
+  running unconfined is a choice the log records rather than a default nobody
+  sees.
+- CI: `sensitivity-check` installs the pinned Rust toolchain before syncing
+  (the sync compiles the extension); a release run that skipped PyPI attaches
+  its wheels and sdist to the GitHub release instead of shipping none.
+- **An expired compute deadline no longer kills the process.** The release
+  profile set `panic = "abort"`, so the deadline — which fires as a panic on
+  purpose, because the phases it guards return no `Result` — reached a
+  published wheel as SIGABRT instead of an error (measured: signal 6 from a
+  `pip install`ed 1.15.0 wheel). For the MCP server, which abandons a
+  timed-out worker thread and keeps serving, that took every concurrent
+  request down with it. The profile now unwinds, which is what lets PyO3
+  convert a panic into a Python exception at all, and the deadline arrives as
+  `TimeoutError` (`_diffctx.ComputeTimeoutError`) that a caller can catch. The
+  test profile is now the shipped profile: the old `release-unwind` clone is
+  exactly what let this mechanism pass its own test while aborting in
+  production.
+- **A timeout too small for git to answer no longer accuses the repository.**
+  `is_git_repo` collapsed every failure into "false", so `timeout=0` reported
+  a valid repo as "not a git repository" instead of saying it timed out.
+- **The `changed` role is recorded where the substitution happens** (#209),
+  not re-derived from a shared start line in three places (pack render,
+  `locate`, and the post-pass coverage rank, the last scanning every core id
+  per candidate). `SelectionResult::stand_in_ids` carries the fact and
+  `types::carries_change` is the single predicate.
+- **`<script type=>` is read from the AST** rather than scanned out of the
+  start tag's text (#213), so `type = "..."` with spaces around the `=` and
+  single-quoted values are handled by the grammar instead of by hand.
+
+- **The per-file admission gate (#65) now covers every selection path**
+  (#211): both post-selection passes and both singleton comparators used to
+  admit files the greedy was forbidden to open. The rescue pass keeps a
+  measured escape — when the selection holds no context at all, an admissible
+  answer beats an empty one. Singletons admit via a wider declared-relation
+  reachability (config keys, latex/terraform references) so weak-but-declared
+  channels are not starved. Net on the 2725-case oracle corpus: 133 cases
+  fixed, 6 explained regressions (`known_below_threshold.txt` 195 → 68).
+- **`--alpha` now actually reaches PPR scoring** (it was validated and then
+  silently discarded; every run used the default damping regardless).
+- **A fragment deferred by the per-file ceiling still sets the stopping
+  peak** (#197): the tau bar was being calibrated on whatever foreign-file
+  fragment came after the deferred argmax.
+- **Test-file imports are read from every fragment of the file** (#217):
+  module-level imports land in a fragment appended after the definitions, so
+  the old first-fragment read never saw them and the `test_direct` weight
+  never fired for tree-sitter languages. Test-naming edges also join the
+  naming class, so a `widget_test.go` with no import is admissible context.
+
+## [1.15.0] - 2026-08-19
+
 ### Added
 
 - **Changed files that produced no fragments are disclosed in the md/text
@@ -167,8 +685,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   precision, because BM25 gives any generic-token match a small positive score
   and `1/(k + rank)` promotes it to real fused mass. `pit` keeps the position
   instead, via each component's empirical CDF: a fragment in the 5th percentile
-  of a signal contributes 0.05 from it, so two weak opinions cannot manufacture a
-  strong candidate. `score = blend·PIT(ego) + (1-blend)·PIT(bm25) + bonus·[both
+  of a signal contributes 0.05 from it, so two weak opinions cannot manufacture
+  a strong candidate. `score = blend·PIT(ego) + (1-blend)·PIT(bm25) + bonus·[both
   in top-k]`, with `DIFFCTX_PIT_BLEND=0.65`, `DIFFCTX_PIT_AGREEMENT_BONUS=0.10`,
   `DIFFCTX_PIT_AGREEMENT_TOP_K=20`. Measured on the full corpus it recovers 40 of
   those 79 cases (`rrf` 450 below-threshold, `pit` 410) and still trails `ego`
@@ -881,9 +1399,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   mapping and `--diff` context, since such material is never legitimate LLM
   context: `*.pem`, `*.key`, `*.pfx`, `*.p12`, `*.keystore`, `*.jks`, and SSH
   private keys `id_rsa`/`id_dsa`/`id_ecdsa`/`id_ed25519` (public `.pub` keys stay
-  visible). The `--diff` path previously applied no ignore filtering at all, so a
-  changed key file would have leaked into context. Use `--no-default-ignores` to
-  opt out of tree-mode default ignores. (`.env` files are intentionally still
+  visible). The `--diff` path previously applied no ignore filtering at all, so
+  a changed key file would have leaked into context. Use `--no-default-ignores`
+  to opt out of tree-mode default ignores. (`.env` files are intentionally still
   included — a changed `.env` is legitimate change context; redacting secret
   *values* is a separate planned content-scan feature.)
 
@@ -1033,7 +1551,9 @@ Earlier releases shipped as `treemapper`; see
 <https://github.com/nikolay-e/diffctx/releases> for the corresponding GitHub
 release notes (`1.0.0` through `1.6.1`).
 
-[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.14.0...HEAD
+[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.16.0...HEAD
+[1.16.0]: https://github.com/nikolay-e/diffctx/compare/v1.15.0...v1.16.0
+[1.15.0]: https://github.com/nikolay-e/diffctx/compare/v1.14.0...v1.15.0
 [1.14.0]: https://github.com/nikolay-e/diffctx/compare/v1.13.0...v1.14.0
 [1.13.0]: https://github.com/nikolay-e/diffctx/compare/v1.12.3...v1.13.0
 [1.12.3]: https://github.com/nikolay-e/diffctx/compare/v1.12.2...v1.12.3