weavatrix 0.2.15 → 0.2.18

package/README.md

@@ -14,6 +14,26 @@ the defaults, no repository data leaves your machine.**
 - Source: [github.com/sergii-ziborov/weavatrix](https://github.com/sergii-ziborov/weavatrix)
 - npm: [`weavatrix`](https://www.npmjs.com/package/weavatrix) — `npx -y weavatrix <repoRoot>`
 
+## 0.3 boundary: offline stays MIT
+
+The next major boundary makes this package the complete offline engine: graph,
+local semantic precision, Health, dependencies, duplicates, impact, history and
+architecture safeguards remain here under the existing MIT license. The MIT
+license is not changing.
+
+Every outbound HTTP capability moves to a separately versioned public package,
+`weavatrix-online`, beginning at 0.1.0. That connector targets either the
+managed Weavatrix Cloud or a commercially licensed self-hosted Weavatrix
+Enterprise deployment through one source-free wire contract. It is a thin
+extension of this package, not a fork of the parser/graph/Health engine, so core
+updates arrive as normal dependency updates.
+
+Version 0.2.18 still contains the explicit opt-in compatibility profiles
+documented below. The paired 0.3/0.1 release removes their network
+implementations from this package; until then the new connector is not
+publishable. The decision and release gates are in
+[docs/adr/0001-v0.3-offline-online-split.md](docs/adr/0001-v0.3-offline-online-split.md).
+
 ## One graph, many views
 
 The 38 MCP methods are not one linear workflow. They project the same reusable graph into the
@@ -117,10 +137,20 @@ Every dead-code, orphan, dependency and duplicate item remains review evidence.
 conventions and source use before editing; Weavatrix does not auto-delete or merge findings.
 
 `run_audit` also returns an explicit capability matrix. `STRUCTURE CHECKED` and a supported package
-ecosystem do not imply `RUNTIME_CORRECTNESS` or `CONCURRENCY` is complete. Maven/Gradle manifests are
-reported `NOT_SUPPORTED`/`PARTIAL` for import-to-artifact verification rather than as a false clean
-`0 declared / 0 external`; bounded Go/Java correctness checks disclose that they are neither compiler
-proof nor a race detector.
+ecosystem do not imply `RUNTIME_CORRECTNESS` or `CONCURRENCY` is complete. npm, nested Python and Go
+modules, Maven properties, common Gradle declarations/version catalogs, and Cargo workspace/renamed
+packages are compared with indexed imports. JVM reflection/generated/runtime-only use, Cargo
+features/proc macros and unresolved build logic remain review evidence; bounded Go/Java checks are
+neither compiler proof nor a race detector.
+
+### Where this saves agent context — and where it does not
+
+The largest saving comes from graph operations that replace repeated discovery: one
+`change_impact`, `get_dependents`, `context_bundle`, contract trace or dependency audit can collapse
+many search/read hops into a bounded evidence set. `read_source` is mainly a convenient exact window
+and is not inherently cheaper than a client's native offset read. Database queries, runtime state,
+disk forensics and background workflow investigation remain outside a static repository graph.
+Typecheck, tests and runtime checks remain the release authority.
 
 ### Trace an event, queue, worker, cron or CLI flow
 
@@ -259,8 +289,9 @@ and builds a missing graph automatically. A normal
 probes without building and refuses a legacy graph. Retargeting is offline but intentionally changes
 the filesystem boundary for subsequent tools; select `pinned` when that boundary must not move.
 
-An agent skill with recipes ships in [skill/SKILL.md](skill/SKILL.md) — install as
-`~/.claude/skills/weavatrix/SKILL.md`.
+An agent skill with recipes ships in [skill/SKILL.md](skill/SKILL.md) — install it as
+`~/.claude/skills/weavatrix/SKILL.md` for Claude Code or
+`~/.codex/skills/weavatrix/SKILL.md` for Codex.
 
 ## Tools
 
@@ -281,6 +312,13 @@ disabled and only static evidence is active. Java and Rust language-server provi
 their edges never become `EXACT_LSP`, even when a mixed repository reports a complete
 TypeScript/JavaScript overlay.
 
+Configured TypeScript plugins (including Next.js) are recorded but suppressed; repository-local
+plugin code is never loaded. The broad overlay is deliberately budgeted, so `PARTIAL` can mean the
+candidate cap was reached. `get_dependents` then spends a bounded point query on the requested JS/TS
+symbol and replaces direct heuristic references only when exact absence/presence is proven.
+`change_impact` batches the same exact query for changed symbols. Further transitive hops remain
+graph-backed and are labelled as such.
+
 The bounded JS/TS provider is enabled by default for new graphs. Set `WEAVATRIX_PRECISION=off`
 before starting the MCP server for parser-only operation from the first build, or pass
 `precision:"off"` to `rebuild_graph` / `open_repo`. The MCPB installer exposes the same `lsp` / `off`
@@ -302,8 +340,8 @@ functions, methods, and symbols, with evidence tiers, completed/remaining verifi
 public/framework/dynamic caveats),
 `run_audit` (an explicit capability matrix plus unused files/exports/dependencies with per-finding manifest/indexed-source/script/config verification;
 `category:dependencies` isolates missing/unused/duplicate declarations, unresolved imports and lockfile drift,
-missing npm/Go/Python deps, honest Maven/Gradle `NOT_SUPPORTED`/`PARTIAL` import verification, bounded
-Go/Java correctness candidates, runtime
+missing npm/Go/Python/Maven/Gradle/Cargo deps, bounded import-to-artifact/crate verification, concrete
+npm/PyPI/Go/Maven/crates.io advisory pins, Go/Java correctness candidates, runtime
 cycles, type-only/compile-only coupling, orphans, boundary rules, offline OSV vulnerabilities + typosquat +
 lockfile drift; accepts an immutable `base_ref`, `changed_files`, and `debt: new|existing|all` for
 review-scoped results; production paths are the default and `include_classified:true` opts into
@@ -392,6 +430,47 @@ metrics are not persisted or transmitted by Weavatrix. If a source checkout's pa
 while an old daemon remains alive, `initialize`, `tools/list`, and tool calls fail loudly with
 `STALE_RUNTIME` until the client reconnects; the opt-out is reserved for deliberate development.
 
+### 0.2.18 repository-root and self-audit trust patch
+
+- A directory nested under an ignored parent Git repository is no longer mistaken for an empty
+  repository. The internal builder now falls back to its boundary-safe walker for that ambiguous
+  case while preserving Git ignore semantics at a real repository root.
+- This is the first npm release containing the 0.2.17 self-audit work: Drizzle reachability,
+  scoped typosquat precision, regex-aware clone anchors, dead parser removal and shared owners.
+- The 0.3 boundary remains unchanged: this offline package stays MIT, and the separately licensed
+  online connector owns outbound HTTP after the major split.
+
+Full patch notes: [docs/releases/v0.2.18.md](docs/releases/v0.2.18.md).
+
+### 0.2.17 self-audit trust patch (tagged, not published to npm)
+
+- Health no longer treats configured Drizzle schema modules as orphaned/test-only production code,
+  and scoped typosquat checks no longer compare legitimate scoped packages with unrelated unscoped
+  names.
+- Duplicate detection retains equality anchors for executable regular-expression bodies, preventing
+  unrelated validation/normalization pipelines from becoming perfect renamed clones.
+- Dogfooding removed obsolete test-only parsers and consolidated dependency-scope, graph-ID,
+  architecture-contract, bounded-option and safe repository-read helpers.
+- The accepted 0.3 product boundary keeps the offline engine MIT and moves all outbound HTTP tools
+  into the separately licensed `weavatrix-online` connector.
+
+Full patch notes: [docs/releases/v0.2.17.md](docs/releases/v0.2.17.md).
+
+### 0.2.16 exact dependents, multi-ecosystem dependencies and transport contracts
+
+- Safe TypeScript project plugins no longer disable semantic precision. Plugin loading remains
+  suppressed, while `get_dependents` and `change_impact` can obtain exact direct JS/TS references on
+  demand and identify graph-backed transitive hops separately.
+- Dependency evidence covers nested npm/Python/Go scopes, Maven properties, Gradle catalogs/locks,
+  and Cargo workspace inheritance/renames/locks. Explicit OSV refresh accepts npm, PyPI, Go, Maven
+  and crates.io pins.
+- Cross-repository tracing adds static GraphQL, gRPC and event-topic joins alongside HTTP and keeps
+  runtime configuration, reflection and other dynamic targets explicitly `UNKNOWN`.
+- npm/MCPB metadata now calls out Codex/OpenAI Codex workflows, and Hosted distinguishes aggregate
+  folder-boundary feedback from proven file-level runtime cycles.
+
+Full patch notes: [docs/releases/v0.2.16.md](docs/releases/v0.2.16.md).
+
 ### 0.2.15 self-audit precision patch
 
 - Dependency review now scopes nested manifests correctly, recognizes framework peer packages and
@@ -658,13 +737,19 @@ Java graphs:
   agent review queue. Public/exported methods, framework entries, decorators, dynamic loading and
   reflection lower confidence; the result always says `REVIEW_REQUIRED` and `autoDelete:false`.
 
-### HTTP clients and wrappers
+### Cross-repository transports
 
 `trace_api_contract` recognizes built-in object clients such as `axios.get(...)`, explicit bare or
 object/member wrappers, and simple auto-discovered functions that forward a URL parameter directly
 to a known HTTP client. Auto-discovered wrappers are restricted to their bounded reverse-import
 scope; ambiguous same-name definitions are skipped and reported as incomplete evidence.
 
+The same tool can select GraphQL, gRPC or event evidence. It joins static GraphQL schema fields and
+operations, proto service methods and typed stub calls, and static Kafka/event-bus topic producers
+and consumers across registered repositories. Computed URLs, runtime configuration, dynamic
+GraphQL documents/topics, reflection and dynamic stubs remain `UNKNOWN`; they are not converted into
+an absence claim.
+
 Persistent per-client-repository configuration lives in `.weavatrix.json`:
 
 ```json
@@ -826,16 +911,17 @@ loader) behind the thin stdio entry `src/mcp-server.mjs`.
   cross-repository wrapper/liveness fixture, framework/convention fixture, full MCP lifecycle gate
   and a portable real-repository runner. Six source-free 0.2.1 real-repository baselines are
   recorded; edge provenance is gated end-to-end and the strict six-repository release command passes.
-- **Wrapper-aware API contracts** shipped in 0.2.2: persistent/ad-hoc configuration,
-  conservative discovery, cross-repository handler liveness and explicit unknown states. The next
-  hosted increment joins privacy-safe contract identities across separately synced services.
+- **Cross-transport contracts** cover bounded HTTP wrappers plus static GraphQL, gRPC and event-bus
+  identities across registered local repositories, with explicit runtime/dynamic unknown states.
 - **Hosted architecture workbench** at
   [app.weavatrix.com](https://app.weavatrix.com) is an access-controlled preview for
   owner-authenticated source-free evidence and revision history. Its UI and backend evolve
   independently from the public MCP release; local use remains fully optional.
 - **Semantic precision bridge** shipped for TypeScript/JavaScript in 0.2.4: a bounded, revision-bound
   local overlay validates references with the bundled language server while the parser graph remains
-  the fallback. Java and Rust providers are not bundled yet and stay explicitly `UNAVAILABLE`.
+  the fallback. 0.2.16 adds safe configured-plugin suppression plus exact on-demand point and changed-
+  symbol batch queries. Java and Rust language-server providers are not bundled and stay explicitly
+  unavailable as semantic providers; their parser/dependency evidence is still active.
 - **Git-native architecture history** — bounded tag/ref timelines and branch
   reports built outside the worktree; graph artifacts stay out of Git.
 - **Cross-repository company evidence** — endpoints, events and internal

package/docs/adr/0001-v0.3-offline-online-split.md

@@ -0,0 +1,58 @@
+# ADR 0001: Weavatrix 0.3 offline/online split
+
+Status: accepted direction; extraction in progress
+
+Date: 2026-07-19
+
+## Decision
+
+The public `weavatrix` package remains MIT licensed and becomes a strictly
+offline MCP in 0.3. Its analyzers, graph, local LSP provider, cache, repository
+registry, Health, dependency, duplicate, impact, history and architecture tools
+remain available without a network capability.
+
+All outbound HTTP tools move to the separate public-source `weavatrix-online`
+package, starting at 0.1.0. Its permission-required source license must be
+approved before publication; the scaffold remains unpublished and
+`UNLICENSED`. It extends the MIT engine rather than copying or relicensing it.
+
+The managed Cloud and licensed self-hosted Enterprise products are private
+server implementations of the same source-free wire contract. Neither is
+bundled into the offline package.
+
+## Tool ownership after extraction
+
+Offline owns local advisory matching but not remote refresh. Online owns:
+
+- `refresh_advisories`;
+- `preview_sync`;
+- `sync_graph`;
+- `pull_architecture_contract`;
+- endpoint capability negotiation and authentication.
+
+The exact final catalog is locked by tests before release. There is no legacy
+`online`, `hosted` or `full` alias in the offline artifact that can re-enable an
+HTTP implementation.
+
+## Update model
+
+`weavatrix-online` depends on a compatible `weavatrix` release and uses a
+supported tool-extension API. Parser, graph schema, LSP and Health fixes are
+therefore updated once in the MIT core. The online repository contains only
+transport, endpoint/authentication and consent-flow code.
+
+## Release gates
+
+The two public packages are released as a compatible pair only after:
+
+1. offline npm, MCPB, skill, server metadata and docs expose no HTTP tools or
+   hosted URL/token inputs;
+2. network action modules and fetch paths are absent from the offline package;
+3. the online connector passes the same local graph/Health regression suite
+   through its core dependency;
+4. Cloud and Enterprise pass one wire-contract suite;
+5. license metadata clearly distinguishes MIT core from permission-required,
+   source-available connector code;
+6. stale 0.2 processes fail clearly rather than advertising mixed catalogs.
+
+Existing MIT releases are unchanged and remain usable under MIT.

package/docs/releases/v0.2.18.md

@@ -0,0 +1,41 @@
+# Weavatrix 0.2.18
+
+0.2.18 is the publishable repository-root and self-audit trust patch. The `v0.2.17` source tag was
+created, but its release validation exposed the nested-root discovery regression before an npm
+package was published. The tag remains immutable; 0.2.18 contains that release plus the fix.
+
+## Repository discovery
+
+- The internal builder distinguishes an actual Git root from a directory that merely lives below
+  another Git repository.
+- When the selected nested directory is ignored by its parent and Git returns an ambiguous empty
+  file universe, Weavatrix uses its boundary-safe filesystem walker instead of building a zero-node
+  graph.
+- A real Git root with an empty tracked/unignored universe stays empty, so ignored build output and
+  secrets are not reintroduced.
+- The live stdio hot-reload regression now exercises the corrected path and passes independently,
+  matching the Linux release runner rather than depending on full-suite ordering.
+
+## Included 0.2.17 trust work
+
+- Drizzle configuration roots its schema modules in production reachability.
+- Scoped typosquat review compares only compatible scoped targets.
+- Executable regular expressions retain equality anchors for clone fingerprints without exposing
+  their source text.
+- Obsolete test-only dependency parsers were removed and repeated dependency, graph and architecture
+  helpers were consolidated under shared owners.
+- Hosted evidence applies the same production-first classification and recomputes bounded summaries
+  after filtering.
+
+## Product boundary
+
+- `weavatrix` remains MIT and offline-first. No license change is made here.
+- The accepted 0.3 split moves outbound HTTP into the separately versioned `weavatrix-online`
+  connector, whose permission-required license remains a release gate.
+
+## Verification
+
+Release validation covers the full Node test suite on supported Node versions, independent hot
+reload execution, release-manifest checks, npm/MCPB packing and runtime smoke tests. The paired
+Hosted deployment is rebuilt from this graph, then verified through its live Health and History
+views.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.2.15",
+  "version": "0.2.18",
   "type": "module",
   "description": "Local repository intelligence MCP for AI coding agents: reusable architecture graph for fast application understanding, Health, dead code, clones, history, blast radius and architecture safeguards.",
   "author": "Sergii Ziborov <sergii.ziborov@gmail.com>",
@@ -26,7 +26,8 @@
     "skill",
     "scripts/run-agent-task-benchmark.mjs",
     "docs/agent-task-benchmark.md",
-    "docs/releases/v0.2.15.md",
+    "docs/adr/0001-v0.3-offline-online-split.md",
+    "docs/releases/v0.2.18.md",
     "README.md",
     "SECURITY.md",
     "LICENSE"
@@ -39,6 +40,7 @@
     "benchmark:real:release": "node scripts/run-real-benchmark.mjs --require-all",
     "benchmark:agent": "node scripts/run-agent-task-benchmark.mjs",
     "benchmark:agent:release": "node scripts/run-agent-task-benchmark.mjs --require-independent",
+    "sync:private": "node scripts/sync-private.mjs",
     "build:mcpb": "node scripts/build-mcpb.mjs",
     "verify:release": "node scripts/verify-release.mjs"
   },
@@ -56,6 +58,9 @@
     "dependency-graph",
     "tree-sitter",
     "claude",
+    "codex",
+    "openai-codex",
+    "coding-agents",
     "ai-agents"
   ],
   "dependencies": {

package/src/analysis/cargo-dependency-evidence.js

@@ -0,0 +1,105 @@
+import { createRepoBoundary } from "../repo-path.js";
+import { cargoName, parseCargoToml } from "./cargo-manifests.js";
+import { dependencyVerification, makeFinding } from "./findings.js";
+import { listRepoFiles, readRepoText } from "./internal-audit.collect.js";
+import { dependencyScopeOwnsFile, dependencyScopeRoot } from "./dependency/scoped-dependencies.js";
+
+export function collectCargoDependencyEvidence(repoRoot, { files = listRepoFiles(repoRoot), externalImports = [] } = {}) {
+  const boundary = createRepoBoundary(repoRoot);
+  const manifests = files.filter((file) => /(^|\/)Cargo\.toml$/i.test(file));
+  const scopes = manifests.map((file) => ({ file, root: dependencyScopeRoot(file), ...parseCargoToml(readRepoText(boundary, file)) }))
+    .sort((left, right) => right.root.length - left.root.length || left.root.localeCompare(right.root));
+  const workspaceDeps = new Map();
+  for (const scope of scopes) for (const dependency of scope.workspaceDependencies) workspaceDeps.set(cargoName(dependency.alias), dependency);
+  const issues = [];
+  for (const scope of scopes) {
+    scope.dependencies = scope.dependencies.map((dependency) => {
+      if (!dependency.inherited) return dependency;
+      const inherited = workspaceDeps.get(cargoName(dependency.alias));
+      if (!inherited) { issues.push(`${scope.file}: workspace dependency ${dependency.alias} is unresolved`); return dependency; }
+      return { ...dependency, name: inherited.name, version: inherited.version, inherited: true };
+    });
+  }
+  const importsByScope = new Map(scopes.map((scope) => [scope, []]));
+  for (const entry of externalImports) {
+    if (entry.ecosystem !== "crates.io" || !entry.pkg || entry.builtin || entry.unresolved) continue;
+    const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, entry.file));
+    if (owner) importsByScope.get(owner).push(entry);
+  }
+  const findings = [], declared = new Set();
+  let mappedImports = 0, unmappedImports = 0;
+  if (!scopes.length) {
+    const missing = new Map();
+    for (const entry of externalImports.filter((item) => item.ecosystem === "crates.io" && item.pkg && !item.builtin && !item.unresolved)) {
+      if (!missing.has(cargoName(entry.pkg))) missing.set(cargoName(entry.pkg), entry);
+    }
+    for (const [name, entry] of missing) findings.push(makeFinding({
+      category: "unused", rule: "missing-dep", severity: "low", confidence: "high",
+      title: `Rust crate path without Cargo.toml: ${name}`,
+      reason: "An indexed external Rust crate path exists, but no Cargo.toml was discovered.",
+      detail: `"${entry.spec || name}" is used by ${entry.file}, but no Cargo manifest owns the file.`,
+      package: name, file: entry.file, line: entry.line || 0, source: "internal",
+      verification: { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "ACTION_REQUIRED", manifestDeclaration: { status: "NOT_PRESENT" }, indexedSourceImports: { status: "FOUND", count: 1, files: [entry.file] }, mapping: "Cargo crate name normalization" },
+      fixHint: "initialize or restore the owning Cargo manifest",
+    }));
+  }
+  for (const scope of scopes) {
+    const imports = importsByScope.get(scope);
+    const used = new Map(), missingSeen = new Set();
+    for (const entry of imports) {
+      const imported = cargoName(entry.pkg);
+      const dependency = scope.dependencies.find((item) => cargoName(item.alias) === imported || cargoName(item.name) === imported);
+      if (dependency) {
+        const evidence = used.get(dependency.alias) || [];
+        evidence.push(entry); used.set(dependency.alias, evidence); mappedImports++;
+        continue;
+      }
+      unmappedImports++;
+      if (missingSeen.has(imported)) continue;
+      missingSeen.add(imported);
+      findings.push(makeFinding({
+        category: "unused", rule: "missing-dep", severity: "medium", confidence: "high",
+        title: `Missing Cargo dependency: ${entry.pkg}`,
+        reason: "An indexed external Rust crate path has no matching dependency alias or package name in the nearest Cargo.toml.",
+        detail: `"${entry.spec || entry.pkg}" is used by ${entry.file}, but ${scope.file} does not declare crate "${entry.pkg}" (including workspace inheritance and renamed packages).`,
+        package: entry.pkg, file: entry.file, line: entry.line || 0, manifest: scope.file,
+        evidence: [{ file: entry.file, line: entry.line || 0, snippet: entry.spec || "" }], source: "internal",
+        verification: { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "ACTION_REQUIRED", manifestDeclaration: { status: "NOT_FOUND", file: scope.file }, indexedSourceImports: { status: "FOUND", count: 1, files: [entry.file] }, mapping: "Cargo alias/package normalization" },
+        fixHint: `cargo add ${entry.pkg}`,
+      }));
+    }
+    for (const dependency of scope.dependencies) {
+      const identity = cargoName(dependency.name);
+      if (!identity) continue;
+      declared.add(`${scope.root || "."}:${identity}`);
+      const evidence = used.get(dependency.alias) || [];
+      if (evidence.length || dependency.optional || dependency.build) continue;
+      findings.push(makeFinding({
+        category: "unused", rule: "unused-dep", severity: dependency.dev ? "info" : "low", confidence: "low",
+        title: `Unused Cargo dependency: ${dependency.name}`,
+        reason: "No indexed Rust use/path/extern-crate evidence maps to this dependency; feature-only, proc-macro, generated and reflective registration remain possible.",
+        detail: `"${dependency.name}" (${dependency.alias}) is declared in ${scope.file}, but no indexed .rs file in that Cargo scope references its crate path. Confirm with cargo check/test and feature combinations before removal.`,
+        package: dependency.name, version: dependency.version, manifest: scope.file, source: "internal",
+        verification: dependencyVerification(scope.file, [], "REVIEW_REQUIRED", "Cargo alias/package normalization"),
+        fixHint: `cargo remove ${dependency.alias} after checking all features and targets`,
+      }));
+    }
+  }
+  const present = manifests.length > 0;
+  return {
+    present,
+    status: present ? "CHECKED" : "NOT_PRESENT",
+    completeness: present ? (issues.length ? "PARTIAL" : "COMPLETE") : "NOT_APPLICABLE",
+    manifests,
+    declared,
+    mappedImports,
+    unmappedImports,
+    findings,
+    reasons: issues,
+    reason: !present
+      ? "No Cargo.toml was discovered."
+      : issues.length
+        ? `Cargo declarations and indexed crate paths were checked, but ${issues.length} workspace inheritance reference(s) remain unresolved.`
+        : `Cargo declarations from ${manifests.length} scope(s), workspace inheritance, renamed packages and every indexed external crate path were compared.`,
+  };
+}

package/src/analysis/cargo-manifests.js

@@ -0,0 +1,74 @@
+const clean = (value) => String(value || "").trim().replace(/^['"]|['"]$/g, "");
+export const cargoName = (value) => clean(value).toLowerCase().replace(/_/g, "-");
+
+function inlineTable(value) {
+  const fields = new Map();
+  for (const match of String(value || "").matchAll(/([A-Za-z][\w.-]*)\s*=\s*("(?:\\.|[^"])*"|'(?:\\.|[^'])*'|true|false)/g)) {
+    fields.set(match[1], clean(match[2]));
+  }
+  return fields;
+}
+
+// Bounded Cargo.toml parser for package/workspace dependency tables. It intentionally owns
+// dependency identity, aliases and concrete versions; feature activation is not treated as usage.
+export function parseCargoToml(text) {
+  const source = String(text || "");
+  const dependencies = [];
+  const workspaceDependencies = [];
+  let section = "", packageName = "", workspace = false;
+  for (const raw of source.split(/\r?\n/)) {
+    const line = raw.replace(/(^|\s)#.*$/, "").trim();
+    if (!line) continue;
+    const header = /^\[([^\]]+)]$/.exec(line);
+    if (header) { section = header[1].trim(); workspace ||= section === "workspace"; continue; }
+    const kv = /^([A-Za-z0-9_-]+)\s*=\s*(.+)$/.exec(line);
+    if (!kv) continue;
+    if (section === "package" && kv[1] === "name") { packageName = clean(kv[2]); continue; }
+    const dependencyTable = /^(?:target\..+\.)?(dependencies|dev-dependencies|build-dependencies)$/.exec(section);
+    const workspaceTable = section === "workspace.dependencies";
+    if (!dependencyTable && !workspaceTable) continue;
+    const alias = kv[1], value = kv[2].trim();
+    const table = value.startsWith("{") ? inlineTable(value) : new Map();
+    const version = value.startsWith("{") ? clean(table.get("version")) : clean(value);
+    const name = clean(table.get("package")) || alias;
+    const record = {
+      alias,
+      name,
+      version: /^\d/.test(version) || /^=?\s*\d/.test(version) ? version.replace(/^=\s*/, "") : "",
+      dev: dependencyTable?.[1] === "dev-dependencies",
+      build: dependencyTable?.[1] === "build-dependencies",
+      optional: table.get("optional") === "true",
+      inherited: table.get("workspace") === "true",
+    };
+    (workspaceTable ? workspaceDependencies : dependencies).push(record);
+  }
+  return { packageName, workspace, dependencies, workspaceDependencies };
+}
+
+// Cargo.lock v3/v4 [[package]] records. Registry packages are exact installed crates; workspace
+// and git packages are excluded because OSV crates.io versions must not be inferred for them.
+export function parseCargoLockPackages(text) {
+  const packages = [];
+  let current = null;
+  const flush = () => {
+    if (current?.name && current.version && /^registry\+https:\/\/github\.com\/rust-lang\/crates\.io-index|^registry\+https:\/\/index\.crates\.io\//.test(current.source)) {
+      packages.push({ ecosystem: "crates.io", name: current.name, version: current.version, dev: false, integrity: current.checksum || "", source: "cargo-lock" });
+    }
+  };
+  for (const raw of String(text || "").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "[[package]]") { flush(); current = { name: "", version: "", source: "", checksum: "" }; continue; }
+    if (!current) continue;
+    if (/^\[/.test(line)) { flush(); current = null; continue; }
+    const match = /^(name|version|source|checksum)\s*=\s*"([^"]+)"/.exec(line);
+    if (match) current[match[1]] = match[2];
+  }
+  flush();
+  const seen = new Set();
+  return packages.filter((pkg) => {
+    const key = `${pkg.name}@${pkg.version}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/analysis/dep-check-ecosystems.js

@@ -194,6 +194,9 @@ export function computePyDepFindings(options = {}) {
     findings.push(...result.findings.map((finding) => ({
       ...finding,
       ...(scope.manifests?.length ? {manifest: scope.manifests[0]} : {}),
+      verification: finding.rule === "missing-dep"
+        ? { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "ACTION_REQUIRED", manifestDeclaration: { status: scope.present ? "NOT_FOUND" : "NOT_PRESENT", files: scope.manifests || [] }, indexedSourceImports: { status: "FOUND", count: finding.evidence?.length || 1, files: (finding.evidence || []).map((item) => item.file) }, mapping: "PEP 503 plus bounded import-to-distribution aliases" }
+        : { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "REVIEW_REQUIRED", manifestDeclaration: { status: "FOUND", files: scope.manifests || [] }, indexedSourceImports: { status: "ZERO_FOUND", completeness: "COMPLETE_FOR_GRAPH_SCOPE", count: 0, files: [] }, mapping: "PEP 503 plus bounded import-to-distribution aliases" },
     })));
     for (const name of result.declared) declared.add(`${scope.root || "."}:${name}`);
     for (const name of result.managed) managed.add(name);

package/src/analysis/dependency/scoped-dependencies.js

@@ -1,5 +1,11 @@
-const normalizeScope = (root) => String(root || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, '')
-const ownsFile = (scope, file) => !scope || file === scope || String(file || '').startsWith(`${scope}/`)
+import {posix} from 'node:path'
+
+export const normalizeDependencyScope = (root) => String(root || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, '')
+export const dependencyScopeRoot = (manifest) => {
+    const root = posix.dirname(normalizeDependencyScope(manifest))
+    return root === '.' ? '' : root
+}
+export const dependencyScopeOwnsFile = (scope, file) => !scope || file === scope || String(file || '').startsWith(`${scope}/`)
 
 // Bind the ecosystem-specific core without introducing a facade/helper import cycle.
 export function createScopedDepFindings(computeDepFindings) {
@@ -8,25 +14,25 @@ export function createScopedDepFindings(computeDepFindings) {
         sourceTexts = new Map(), nonRuntimeRoots = [], sourceFiles = [],
     } = {}) {
         const scopes = packageScopes.length
-            ? packageScopes.map((scope) => ({...scope, root: normalizeScope(scope.root)})).sort((a, b) => b.root.length - a.root.length)
+            ? packageScopes.map((scope) => ({...scope, root: normalizeDependencyScope(scope.root)})).sort((a, b) => b.root.length - a.root.length)
             : [{root: '', manifest: 'package.json', pkg: {}, aliases: []}]
         const importsByScope = new Map(scopes.map((scope) => [scope, []]))
         const sourceFilesByScope = new Map(scopes.map((scope) => [scope, []]))
         const sourceTextsByScope = new Map(scopes.map((scope) => [scope, new Map()]))
         for (const item of externalImports) {
-            const owner = scopes.find((scope) => ownsFile(scope.root, item.file)) || scopes[scopes.length - 1]
+            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, item.file)) || scopes[scopes.length - 1]
             importsByScope.get(owner).push(item)
         }
         for (const file of sourceFiles) {
-            const owner = scopes.find((scope) => ownsFile(scope.root, file)) || scopes[scopes.length - 1]
+            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1]
             sourceFilesByScope.get(owner).push(file)
         }
         for (const [file, text] of sourceTexts) {
-            const owner = scopes.find((scope) => ownsFile(scope.root, file)) || scopes[scopes.length - 1]
+            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1]
             sourceTextsByScope.get(owner).set(file, text)
         }
         const configOwner = new Map()
-        for (const [file] of configTexts) configOwner.set(file, scopes.find((scope) => ownsFile(scope.root, file)) || scopes[scopes.length - 1])
+        for (const [file] of configTexts) configOwner.set(file, scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1])
         const findings = [], usedPackages = new Map(), declared = new Set()
         for (const scope of scopes) {
             const scopeConfig = new Map([...configTexts].filter(([file]) => configOwner.get(file) === scope))

package/src/analysis/duplicates.tokenize.js

@@ -3,9 +3,16 @@
 
 const K = 8;               // k-gram length (tokens)
 const W = 4;               // winnowing window → guaranteed detection of matches ≥ K+W-1 tokens
-const STRLIT = String.fromCharCode(0); // opaque-literal sentinel for every string/regex body: a NUL
+const STRLIT = String.fromCharCode(0); // opaque-literal sentinel for string bodies: a NUL
                            // its own class (never an identifier "I" nor a number "N"), so a literal can
                            // never masquerade as code in either mode
+const REGEXLIT = String.fromCharCode(1); // regex bodies are executable behavior, so retain an equality anchor
+const literalHash = (value) => {
+  let hash = 2166136261;
+  for (const char of String(value || "")) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+  return (hash >>> 0).toString(16);
+};
+const regexMarker = (value) => ` ${REGEXLIT} 0x${literalHash(value)} `;
 
 const KEYWORDS = new Set(("if else for while do switch case break continue return function const let var new class extends async await try catch finally throw import from export default typeof instanceof in of delete void yield static get set this super null undefined true false def elif except lambda pass raise with as is not and or None True False func go defer chan map range struct interface type package nil err string int bool byte float64 public private protected final void long double boolean").split(" "));
 
@@ -16,9 +23,9 @@ const KEYWORDS = new Set(("if else for while do switch case break continue retur
 // regex and ate the rest of the line.
 const REGEX_PREV = new Set("(,=:[!&|?{};~*%^<>".split(""));
 
-// Replace comments with nothing and string/regex BODIES with the sentinel, so their contents never
-// count as code. Handles Python triple-quoted docstrings (embedded quotes no longer desync the scan)
-// and JS regex literals (a quote inside /['"]/ no longer opens a phantom string).
+// Replace comments with nothing and string bodies with an opaque sentinel. Regex bodies retain only
+// a one-way equality anchor: their source is executable behavior, and collapsing every pattern to the
+// same token creates false clone groups for unrelated replace/validate pipelines.
 export function stripNonCode(text, py) {
   let out = "", i = 0, prevSig = "";
   const s = String(text || "");
@@ -34,7 +41,7 @@ export function stripNonCode(text, py) {
     if (!py && two === "//") { while (i < s.length && s[i] !== "\n") i++; continue; }
     if (!py && two === "/*") { i += 2; while (i < s.length && s.slice(i, i + 2) !== "*/") i++; i += 2; continue; }
     if (!py && ch === "/" && REGEX_PREV.has(prevSig)) {
-      i++; let inClass = false; // '/' inside a [...] char class is literal, not the terminator
+      i++; const regexStart = i; let inClass = false; // '/' inside a [...] char class is literal, not the terminator
       while (i < s.length && s[i] !== "\n") {
         const c = s[i];
         if (c === "\\") { i += 2; continue; }
@@ -44,7 +51,7 @@ export function stripNonCode(text, py) {
         i++;
       }
       while (i < s.length && /[a-z]/i.test(s[i])) i++; // regex flags (gimsuy)
-      push(` ${STRLIT} `); continue;
+      push(regexMarker(s.slice(regexStart, i))); continue;
     }
     if (ch === '"' || ch === "'" || ch === "`") {
       const q = ch; i++;

package/src/analysis/endpoints-java.js

@@ -2,16 +2,13 @@
 // literal annotation paths: inventing values for constants would make an architecture inventory look
 // more complete than the evidence permits.
 import { maskJavaNonCode } from "./java-source.js";
+import { lineNumberAt } from "../util.js";
 
 const SPRING_MAPPING = /@(?:org\.springframework\.web\.bind\.annotation\.)?(RequestMapping|GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping)\b/g;
 const SPRING_CONDITION = /@(?:org\.springframework\.boot\.autoconfigure\.condition\.)?(ConditionalOnExpression|ConditionalOnProperty)\b/g;
 const REQUEST_METHOD = /\bRequestMethod\s*\.\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b/g;
 
-const lineAt = (text, index) => {
-  let line = 1;
-  for (let i = 0; i < index && i < text.length; i++) if (text[i] === "\n") line++;
-  return line;
-};
+const lineAt = lineNumberAt;
 
 function skipTrivia(text, start) {
   let i = start;

package/src/analysis/findings.js

@@ -6,6 +6,18 @@ import { createHash } from "node:crypto";
 export const SEVERITY_ORDER = ["critical", "high", "medium", "low", "info"];
 export const FINDING_CATEGORIES = ["unused", "structure", "vulnerability", "malware"];
 
+export function dependencyVerification(manifest, imports, decision, mapping) {
+  return {
+    evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE",
+    decision,
+    manifestDeclaration: { status: "FOUND", file: manifest },
+    indexedSourceImports: imports.length
+      ? { status: "FOUND", count: imports.length, files: [...new Set(imports.map((item) => item.file))].slice(0, 10) }
+      : { status: "ZERO_FOUND", completeness: "COMPLETE_FOR_GRAPH_SCOPE", count: 0, files: [] },
+    mapping,
+  };
+}
+
 // Stable id: survives re-runs so the UI can persist expand/dismiss state per finding.
 export function makeFinding(f) {
   const cycleIdentity = Array.isArray(f.cycleMembers)