diffctx 1.17.0__tar.gz → 1.18.1__tar.gz

{diffctx-1.17.0 → diffctx-1.18.1}/CHANGELOG.md

@@ -7,10 +7,100 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.18.1] - 2026-09-30
+
+### Fixed
+
+- **The plugin's impact hook never ran under macOS `/bin/bash` 3.2**: an empty
+  `gate=()` expanded under `set -u` is an unbound variable there, the pipeline
+  died right of the pipe and `|| true` hid it. One never-empty argument array.
+- Hook command parsing: `git add … && git commit` reviews the working tree
+  (the add has not run when the hook sees the line — it reviewed the stale
+  index and was silent on the commonest agent pattern); `-m a -m b`, `-F file`
+  and other value flags no longer count as pathspecs; `git diff A B` and
+  `git diff main` are history, not the pending change; `cd dir && git …` and
+  a relative `-C` resolve against the agent's cwd.
+- Impact: a test guards a caller only when it names the symbol *and* reaches
+  the caller's module (a Rust test mentioning `render` was the guard of a
+  Python `render()`, #312); a chunk caller named `main[88]` is looked up as
+  `main`; two-letter modules (`db.py`) keep their callers; `*out = f()` and
+  `#[derive]` lines are code, not comments; a wide changed-file list folds
+  into a count before a single caller is dropped, and a symbol keeps its
+  strongest caller; a run that hit a limit says `(partial: …)` and is never
+  `empty`; schema contracts are listed before public symbols with a `+N more`
+  count; SHA-256 repositories count commits.
+- `diffctx.impact.v1` and `diffctx.locate.v1` required every field the
+  serializer may omit (`truncated`, `commit_count`, `deleted_files`, …), so no
+  real document validated; the schemas now require what is always present,
+  and a test validates real impact and locate output against them.
+- MCP: the default `diff_ref` on a clean single-commit repository is the
+  working tree, not an error naming a range the caller never passed; the
+  `git status` guess runs off the event loop with a 10 s cap and never leaks
+  the command line into the response.
+- CLI: `--mode impact -o out.yaml` is refused like `-f yaml` instead of
+  writing JSON silently; `--mode` help names the text default.
+- Plugin installer: the download is unpacked beside its target so the final
+  `mv` is a rename, never a copy another session could execute half-written.
+- MCP `mode=impact` with `paths` no longer marks the whole change reviewed.
+- Landing page: the four-part iOS viewport contract (`viewport-fit=cover`,
+  status-bar style, safe-area insets, taller `html`).
+- Privacy page names the release-binary download the plugin makes.
+- `bitcheck.sh` ranges re-pinned on the rewritten history; the old anchors
+  kept the pre-rewrite tree, with third-party tokens in retired benchmark
+  diffs, reachable on both forges.
+- Runtime image: one package layer (Sonar `docker:S7031`/`S6595`); PyJWT
+  2.15.1 in `uv.lock` (GHSA-w6j9-cwv2-h6wq, transitive).
+
+## [1.18.0] - 2026-09-29
+
+### Added
+
+- **`--mode impact`: what a change reaches outside its own diff, under 2k
+  tokens.** For each changed symbol, the callers in files the diff does not
+  touch, whether a test guards each one, and which symbols more than one
+  commit of the range edited; public API and schema changes are listed as
+  facts. It walks the graph the other modes already build, with a discovery
+  pass that follows references *into* the changed files (the other modes
+  only follow what the changed files import), and filters name-only links
+  the way a reader would: the caller must name the symbol in code and
+  reference its module. An empty impact is an answer, not an error. CLI
+  (`-f md` is the text form), MCP `mode="impact"`, the GitHub Action's
+  `mode` input, and `schemas/diffctx.impact.v1.json`.
+- **`diffctx hook pretooluse` / `posttooluse`: the Claude Code plugin hands
+  the agent a change's impact without asking it to call anything.** Eight
+  agent sessions with the tool installed made zero unprompted calls (#289).
+  Before a commit, merge, cherry-pick, push or pull request the impact of
+  what that command records is injected as context — a plain `git commit`
+  reviews the index, `-a` the working tree, a merge the branch since its
+  merge base; after a `git diff` or `git status` the agent ran itself, the
+  pending change's impact rides on the answer it asked for. Once per change
+  (content-keyed with `git patch-id`, so a manual `--mode impact` run
+  counts), silent when nothing outside the diff depends on the change, and
+  never blocking: a range that runs out of the 30 s deadline is marked
+  reviewed rather than retried on every push. `impact_gate` (off by default)
+  denies a commit until its impact was shown once. At session start the
+  plugin fetches the release binary for the platform, verified against
+  `checksums.json`, into its data directory, backs off for six hours after a
+  failed download, and puts the one-line recipe into the session's context;
+  `impact_hook` turns all of it off (#310).
+- **`/diffctx:commit`**: the impact first, then the commit.
+- **`diffctx_context` is always loaded** under Claude Code's tool search
+  (`_meta.anthropic/alwaysLoad`), and its description names `impact` as the
+  pre-commit call; both skills default to the server's own range choice.
+- **The PR review comment opens with the impact view.**
+- **Plugin eval `breaking-caller`** measures the number under the goal: with
+  a contract change uncommitted and two callers about to break, does the
+  agent handle or name them before committing.
+
 ## [1.17.0] - 2026-09-23
 
 ### Added
 
+- **The site lives at <https://diffctx.com>.** It was a 301 to
+  `nikolay-e.github.io/diffctx/`, so search engines indexed the github.io
+  URL and the product domain had no presence of its own. It is now the
+  GitHub Pages custom domain (github.io redirects to it), with a
+  `robots.txt` and `sitemap.xml`; package metadata points at it.
 - **Windows and Intel-Mac are release targets.** Every test matrix runs on
   Linux, macOS and Windows on x64 and ARM; wheels and binaries ship for
   `x86_64-apple-darwin` and `aarch64-pc-windows-msvc` as well, and `npm
@@ -1626,7 +1716,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.17.0...HEAD
+[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.18.1...HEAD
+[1.18.1]: https://github.com/nikolay-e/diffctx/compare/v1.18.0...v1.18.1
+[1.18.0]: https://github.com/nikolay-e/diffctx/compare/v1.17.0...v1.18.0
 [1.17.0]: https://github.com/nikolay-e/diffctx/compare/v1.16.0...v1.17.0
 [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

{diffctx-1.17.0 → diffctx-1.18.1}/Cargo.lock

@@ -194,7 +194,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "diffctx"
-version = "1.17.0"
+version = "1.18.1"
 dependencies = [
  "aho-corasick",
  "anyhow",

{diffctx-1.17.0 → diffctx-1.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.17.0
+Version: 1.18.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -44,15 +44,15 @@ Provides-Extra: mcp
 License-File: LICENSE
 Summary: Selects the minimum code an LLM needs to review a git diff
 Keywords: ai,chatgpt,claude,code-analysis,code-context,code-review,code-to-prompt,codebase,context,context-selection,diff-context,directory-tree,export,git-diff,json,llm,llm-context,mcp,model-context-protocol,tree,yaml
-Home-Page: https://github.com/nikolay-e/diffctx
+Home-Page: https://diffctx.com/
 Author-email: Nikolay Eremeev <nikolay.eremeev@outlook.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Author, https://nikolay-eremeev.com
 Project-URL: Changelog, https://github.com/nikolay-e/diffctx/blob/main/CHANGELOG.md
-Project-URL: Documentation, https://nikolay-e.github.io/diffctx/
-Project-URL: Homepage, https://nikolay-e.github.io/diffctx/
+Project-URL: Documentation, https://diffctx.com/
+Project-URL: Homepage, https://diffctx.com/
 Project-URL: Issues, https://github.com/nikolay-e/diffctx/issues
 Project-URL: Paper, https://doi.org/10.5281/zenodo.18824579
 Project-URL: Repository, https://github.com/nikolay-e/diffctx
@@ -154,7 +154,7 @@ keeps its git meaning.
 | `--full`    | false   | Only the changed files, every fragment, no related-code context          |
 | `--timeout` | 300     | Wall-clock deadline in seconds; on expiry the run stops cooperatively and emits a partial artifact whose `coverage` block names the limit (exit 0). 124 is the watchdog behind it, 30 s later, for a phase that could not stop |
 | `--with-raw-diff` | false | Also embed git's raw unified diff ahead of the selected fragments — additive (selection unchanged), not charged to `--budget`, lock/ignored/secret-like sections omitted. Python CLI only |
-| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `diffctx . --diff --mode locate` = impact of your uncommitted change. The MCP tool takes it as `mode="locate"` |
+| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `impact` answers, under 2k tokens, what the change reaches outside its diff: callers in files the diff does not touch, whether a test guards each, cross-commit overlap, and the public API and schema changes (text by default, `diffctx.impact.v1` JSON with `-f json`). The MCP tool takes both as `mode` |
 
 Every JSON/YAML artifact opens with `schema: diffctx.context.v1` and validates
 against [`schemas/diffctx.context.v1.json`](schemas/diffctx.context.v1.json),
@@ -248,7 +248,10 @@ as `io.github.nikolay-e/diffctx`. One-line setup (zero-install via
 [uv](https://docs.astral.sh/uv/)):
 
 ```bash
-# Claude Code
+# Claude Code plugin: the server plus /diffctx:diffctx and /diffctx:impact
+claude plugin marketplace add nikolay-e/diffctx
+claude plugin install diffctx@diffctx
+# Claude Code, server only
 claude mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
 # Codex CLI
 codex mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
@@ -343,7 +346,7 @@ Apache 2.0
 
 ---
 
-- [Documentation site](https://nikolay-e.github.io/diffctx/) — the pipeline
+- [Documentation site](https://diffctx.com/) — the pipeline
   end to end: diff → fragments → graph → relevance → selection
 - [Command-line reference](docs/product/cli.md) — every flag with its default
   and meaning, rendered from `diffctx --help`

{diffctx-1.17.0 → diffctx-1.18.1}/README.md

@@ -95,7 +95,7 @@ keeps its git meaning.
 | `--full`    | false   | Only the changed files, every fragment, no related-code context          |
 | `--timeout` | 300     | Wall-clock deadline in seconds; on expiry the run stops cooperatively and emits a partial artifact whose `coverage` block names the limit (exit 0). 124 is the watchdog behind it, 30 s later, for a phase that could not stop |
 | `--with-raw-diff` | false | Also embed git's raw unified diff ahead of the selected fragments — additive (selection unchanged), not charged to `--budget`, lock/ignored/secret-like sections omitted. Python CLI only |
-| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `diffctx . --diff --mode locate` = impact of your uncommitted change. The MCP tool takes it as `mode="locate"` |
+| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `impact` answers, under 2k tokens, what the change reaches outside its diff: callers in files the diff does not touch, whether a test guards each, cross-commit overlap, and the public API and schema changes (text by default, `diffctx.impact.v1` JSON with `-f json`). The MCP tool takes both as `mode` |
 
 Every JSON/YAML artifact opens with `schema: diffctx.context.v1` and validates
 against [`schemas/diffctx.context.v1.json`](schemas/diffctx.context.v1.json),
@@ -189,7 +189,10 @@ as `io.github.nikolay-e/diffctx`. One-line setup (zero-install via
 [uv](https://docs.astral.sh/uv/)):
 
 ```bash
-# Claude Code
+# Claude Code plugin: the server plus /diffctx:diffctx and /diffctx:impact
+claude plugin marketplace add nikolay-e/diffctx
+claude plugin install diffctx@diffctx
+# Claude Code, server only
 claude mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
 # Codex CLI
 codex mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
@@ -284,7 +287,7 @@ Apache 2.0
 
 ---
 
-- [Documentation site](https://nikolay-e.github.io/diffctx/) — the pipeline
+- [Documentation site](https://diffctx.com/) — the pipeline
   end to end: diff → fragments → graph → relevance → selection
 - [Command-line reference](docs/product/cli.md) — every flag with its default
   and meaning, rendered from `diffctx --help`

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "diffctx"
-version = "1.17.0"
+version = "1.18.1"
 edition = "2024"
 rust-version = "1.85"
 description = "Selects the minimum code an LLM needs to review a git diff: walks the dependency graph outward from changed lines and stops when extra context stops paying for itself"
 license = "Apache-2.0"
 repository = "https://github.com/nikolay-e/diffctx"
-homepage = "https://github.com/nikolay-e/diffctx"
+homepage = "https://diffctx.com/"
 documentation = "https://docs.rs/diffctx"
 readme = "README.md"
 keywords = ["git", "diff", "llm", "context", "tree-sitter"]

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/README.md

@@ -95,7 +95,7 @@ keeps its git meaning.
 | `--full`    | false   | Only the changed files, every fragment, no related-code context          |
 | `--timeout` | 300     | Wall-clock deadline in seconds; on expiry the run stops cooperatively and emits a partial artifact whose `coverage` block names the limit (exit 0). 124 is the watchdog behind it, 30 s later, for a phase that could not stop |
 | `--with-raw-diff` | false | Also embed git's raw unified diff ahead of the selected fragments — additive (selection unchanged), not charged to `--budget`, lock/ignored/secret-like sections omitted. Python CLI only |
-| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `diffctx . --diff --mode locate` = impact of your uncommitted change. The MCP tool takes it as `mode="locate"` |
+| `--mode` | `pack` | `locate` emits the same ranked selection as compact `diffctx.locate.v1` JSON — path, lines, score, provenance reasons, a blast-radius `summary` and per-item impact `group` (`test`/`type`/`config`), NO source bodies. Adds a `coverage` block naming what the run could not see (`unparsed_files`, `zero_edge_files`, `ppr_truncated`, `next_up`, a heuristic `confidence`) and an `overflow` ranking of what the budget left behind — omitted entirely when there is nothing to disclose. `impact` answers, under 2k tokens, what the change reaches outside its diff: callers in files the diff does not touch, whether a test guards each, cross-commit overlap, and the public API and schema changes (text by default, `diffctx.impact.v1` JSON with `-f json`). The MCP tool takes both as `mode` |
 
 Every JSON/YAML artifact opens with `schema: diffctx.context.v1` and validates
 against [`schemas/diffctx.context.v1.json`](schemas/diffctx.context.v1.json),
@@ -189,7 +189,10 @@ as `io.github.nikolay-e/diffctx`. One-line setup (zero-install via
 [uv](https://docs.astral.sh/uv/)):
 
 ```bash
-# Claude Code
+# Claude Code plugin: the server plus /diffctx:diffctx and /diffctx:impact
+claude plugin marketplace add nikolay-e/diffctx
+claude plugin install diffctx@diffctx
+# Claude Code, server only
 claude mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
 # Codex CLI
 codex mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
@@ -284,7 +287,7 @@ Apache 2.0
 
 ---
 
-- [Documentation site](https://nikolay-e.github.io/diffctx/) — the pipeline
+- [Documentation site](https://diffctx.com/) — the pipeline
   end to end: diff → fragments → graph → relevance → selection
 - [Command-line reference](docs/product/cli.md) — every flag with its default
   and meaning, rendered from `diffctx --help`

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/src/discovery.rs

@@ -117,6 +117,132 @@ fn expand_by_rare_identifiers(ctx: &DiscoveryContext) -> Vec<PathBuf> {
     result
 }
 
+/// Files that name what the change defines: the callers a change reaches
+/// (#310). Forward discovery follows what the changed file imports; nothing
+/// followed the other way, so a function with a hundred importers surfaced
+/// one of them and the impact view called the rest silence. Only the
+/// impact mode asks for this: widening the universe moves selection, and
+/// the corpus operating point is calibrated without it.
+pub struct ReverseReferenceDiscovery;
+
+/// A name held by more candidate files than this is vocabulary, not a
+/// reference, and following it would admit the repository.
+const MAX_REVERSE_FILES_PER_NAME: usize = 64;
+const MAX_REVERSE_FILES: usize = 256;
+const MIN_REVERSE_NAME_LEN: usize = 4;
+
+static DEFINITION_RE: OnceLock<regex::Regex> = OnceLock::new();
+
+fn definition_names(content: &str) -> Vec<String> {
+    let re = DEFINITION_RE.get_or_init(|| {
+        regex::Regex::new(
+            r"(?m)^\s*(?:export\s+(?:default\s+)?|pub(?:\([^)]*\))?\s+|public\s+|static\s+|async\s+|abstract\s+|final\s+|data\s+|sealed\s+|open\s+)*(?:fn|def|class|struct|enum|interface|trait|type|function|const|let|var|val|object|impl|protocol|module|record)\s+([A-Za-z_][A-Za-z0-9_]*)",
+        )
+        .expect("definition regex")
+    });
+    re.captures_iter(content)
+        .filter_map(|c| c.get(1).map(|m| m.as_str().to_string()))
+        .filter(|n| n.len() >= MIN_REVERSE_NAME_LEN)
+        .collect()
+}
+
+impl DiscoveryStrategy for ReverseReferenceDiscovery {
+    fn name(&self) -> &'static str {
+        "reverse_reference"
+    }
+
+    fn discover(&self, ctx: &DiscoveryContext) -> Vec<PathBuf> {
+        let changed_set: FxHashSet<&Path> = ctx.changed_files.iter().map(|p| p.as_path()).collect();
+        // Per changed file: the module name a reference would import it by,
+        // and the names it defines. A file that carries both is a reference
+        // however common the name; one that carries the name alone counts
+        // only while the name is rare enough to mean this definition.
+        let mut per_file: Vec<(Option<String>, FxHashSet<String>)> = Vec::new();
+        for path in &ctx.changed_files {
+            let stem = path
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .filter(|s| s.len() >= MIN_REVERSE_NAME_LEN)
+                .map(|s| s.to_lowercase());
+            let names: FxHashSet<String> = ctx
+                .read_file(path)
+                .map(|c| {
+                    definition_names(&c)
+                        .into_iter()
+                        .map(|n| n.to_lowercase())
+                        .collect()
+                })
+                .unwrap_or_default();
+            if stem.is_some() || !names.is_empty() {
+                per_file.push((stem, names));
+            }
+        }
+        if per_file.is_empty() {
+            return Vec::new();
+        }
+        let mut name_holders: FxHashMap<&str, usize> = FxHashMap::default();
+        let mut strong: Vec<&PathBuf> = Vec::new();
+        let mut weak: Vec<(&PathBuf, Vec<&str>)> = Vec::new();
+        for (path, doc) in &ctx.shared_corpus().docs {
+            if changed_set.contains(path.as_path()) {
+                continue;
+            }
+            let mut is_strong = false;
+            let mut named: Vec<&str> = Vec::new();
+            for (stem, names) in &per_file {
+                let has_stem = stem
+                    .as_deref()
+                    .is_some_and(|s| doc.term_counts.contains_key(s));
+                for name in names {
+                    if doc.term_counts.contains_key(name) {
+                        *name_holders.entry(name.as_str()).or_default() += 1;
+                        named.push(name.as_str());
+                        if has_stem {
+                            is_strong = true;
+                        }
+                    }
+                }
+            }
+            if is_strong {
+                strong.push(path);
+            } else if !named.is_empty() {
+                weak.push((path, named));
+            }
+        }
+        strong.sort();
+        tracing::debug!(
+            "reverse references: {} definition sets, {} strong, {} weak, corpus {}",
+            per_file.len(),
+            strong.len(),
+            weak.len(),
+            ctx.shared_corpus().docs.len()
+        );
+        let mut result: Vec<PathBuf> = Vec::new();
+        let mut seen: FxHashSet<&PathBuf> = FxHashSet::default();
+        for f in strong {
+            if result.len() >= MAX_REVERSE_FILES {
+                return result;
+            }
+            if seen.insert(f) {
+                result.push(f.clone());
+            }
+        }
+        weak.sort_by(|a, b| a.0.cmp(b.0));
+        for (f, named) in weak {
+            if result.len() >= MAX_REVERSE_FILES {
+                break;
+            }
+            let rare = named
+                .iter()
+                .any(|n| name_holders.get(n).copied().unwrap_or(0) <= MAX_REVERSE_FILES_PER_NAME);
+            if rare && seen.insert(f) {
+                result.push(f.clone());
+            }
+        }
+        result
+    }
+}
+
 pub struct TestFileDiscovery;
 
 const TEST_PREFIXES: &[&str] = &["test_", "spec_"];

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/src/edges/semantic/rust_lang.rs

@@ -32,7 +32,10 @@ static FN_DEF_RE: Lazy<Regex> = Lazy::new(|| {
 });
 static TYPE_REF_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([A-Z]\w*)\b").unwrap());
 static FN_CALL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([a-z_]\w+)\s*[(<]").unwrap());
-static PATH_CALL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b(\w+)::(\w+)").unwrap());
+/// Whole `a::b::c` paths; every adjacent pair is a (module, symbol) call so
+/// `crate::pricing::total(..)` names `pricing::total` and not only
+/// `crate::pricing`, which a pairwise regex stopped at.
+static PATH_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b\w+(?:::\w+)+").unwrap());
 static IMPL_RE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"(?m)^\s*impl(?:<[^>]*>)?\s+(\w+)\s+for\s+(\w+)").unwrap());
 static PUB_USE_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?m)^\s*pub\s+use\s+([\w:]+)").unwrap());
@@ -107,9 +110,15 @@ fn extract_references(content: &str) -> References {
             fn_calls.insert(name.to_string());
         }
     }
-    let path_calls: FxHashSet<(String, String)> = PATH_CALL_RE
-        .captures_iter(content)
-        .map(|c| (c[1].to_string(), c[2].to_string()))
+    let path_calls: FxHashSet<(String, String)> = PATH_RE
+        .find_iter(content)
+        .flat_map(|m| {
+            let segments: Vec<&str> = m.as_str().split("::").collect();
+            segments
+                .windows(2)
+                .map(|w| (w[0].to_string(), w[1].to_string()))
+                .collect::<Vec<_>>()
+        })
         .collect();
     References {
         type_refs,

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/src/effective_config.rs

@@ -196,6 +196,7 @@ pub const NON_SEMANTIC_ENV: &[&str] = &[
     "DIFFCTX_ALLOWED_PATHS",
     "DIFFCTX_BENCH_TIMEOUT_SEC",
     "DIFFCTX_BUILD_SHA",
+    "DIFFCTX_CACHE_DIR",
     "DIFFCTX_CONFIG_DIR",
     "DIFFCTX_DIR_IGNORE",
     "DIFFCTX_DIR_WHITELIST",
@@ -204,6 +205,7 @@ pub const NON_SEMANTIC_ENV: &[&str] = &[
     "DIFFCTX_EVAL_STRICT",
     "DIFFCTX_IGNORE_RELPATH",
     "DIFFCTX_MCP_LEGACY_TOOLS",
+    "DIFFCTX_NO_MARKER",
     "DIFFCTX_PROBE_MODE",
     "DIFFCTX_PROBE_TAU",
     "DIFFCTX_PROVENANCE",

{diffctx-1.17.0 → diffctx-1.18.1}/crates/diffctx-native/src/graph.rs

@@ -426,6 +426,39 @@ impl Graph {
         }
     }
 
+    /// Invoke `f(source_id, weight)` for each node with an edge INTO `node`,
+    /// with the weight of that incoming edge.
+    pub fn for_each_reverse_neighbor<F: FnMut(&FragmentId, f64)>(
+        &self,
+        node: &FragmentId,
+        mut f: F,
+    ) {
+        let rev = match self.rev_csr() {
+            Some(c) => c,
+            None => return,
+        };
+        let idx = match rev.node_to_idx.get(node) {
+            Some(&i) => i as usize,
+            None => return,
+        };
+        let s = rev.indptr[idx] as usize;
+        let e = rev.indptr[idx + 1] as usize;
+        for k in s..e {
+            let src_idx = rev.indices[k] as usize;
+            f(&rev.idx_to_node[src_idx], rev.weights[k]);
+        }
+    }
+
+    /// Whether `a -> b` is the stronger direction of the pair. Every builder
+    /// writes the reverse of an edge at `weight * reverse_factor` with the
+    /// factor below one, so the comparison recovers the direction the builder
+    /// meant (caller -> callee, importer -> imported) without a second table.
+    pub fn is_forward(&self, a: &FragmentId, b: &FragmentId) -> bool {
+        let ab = self.forward_edge_weight(a, b).unwrap_or(0.0);
+        let ba = self.forward_edge_weight(b, a).unwrap_or(0.0);
+        ab > ba
+    }
+
     pub fn ego_graph(
         &self,
         seeds: &FxHashSet<FragmentId>,