weavatrix 0.2.16 → 0.2.19

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.19 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
@@ -410,6 +430,44 @@ 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.19 supply-chain signal precision
+
+- Installed-package URL literals and ordinary standalone network calls no longer become malware
+  findings without a separate security signal. They remain bounded co-evidence beside behavior such
+  as environment harvesting, while exfil endpoints, public raw IPs and fetch-plus-exec stay active.
+- Unicode variation selectors used for emoji/presentation are no longer confused with hidden text
+  controls. Bidirectional override/isolate controls remain covered.
+- Real Hosted dogfood now completes OSV over 651 package versions and the local malware sweep over
+  535 installed packages with zero critical/high/medium/low findings.
+
+Full patch notes: [docs/releases/v0.2.19.md](docs/releases/v0.2.19.md).
+
+### 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

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.19.md

@@ -0,0 +1,33 @@
+# Weavatrix 0.2.19
+
+0.2.19 is a supply-chain signal-precision patch. It was produced after the complete Hosted
+installed-package scan exposed false positives in otherwise ordinary dependency content.
+
+## Malware evidence precision
+
+- A hardcoded external URL is no longer sufficient for a malware finding.
+- A standalone `fetch`, Axios, request, curl or wget call to an ordinary external URL is also weak
+  evidence by itself. It remains attached as bounded co-evidence when the same package has a
+  separate security signal, such as whole-environment serialization.
+- Strong URL and execution evidence is unchanged: known exfil/webhook hosts, public raw-IP URLs,
+  cloud metadata endpoints, download-plus-exec lifecycle scripts, reverse shells and miners still
+  produce review findings.
+- Unicode variation selectors (`U+FE00`–`U+FE0F`) are presentation controls commonly used with
+  emoji and no longer trigger hidden-Unicode review. Bidirectional override/isolate controls remain
+  covered because they can conceal source order.
+
+## Verification
+
+- Synthetic end-to-end fixtures prove ordinary URL literals, standalone network calls and variation
+  selectors stay quiet while multi-signal and strong malicious families remain detectable.
+- Real Weavatrix Hosted dogfood checked 651/651 pinned package versions through OSV with no known
+  advisories and scanned 535 installed npm packages with zero malware findings.
+- The same audit reports complete npm declaration/import verification, zero missing dependencies,
+  zero unused dependencies, zero duplicate declarations and zero runtime cycles.
+- Full release tests, release-manifest checks, npm/MCPB pack/runtime smoke and supported Node CI remain
+  mandatory before publication.
+
+## Product boundary
+
+The offline package remains MIT. The accepted 0.3 split and the separate permission-licensed online
+connector are unchanged by this patch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.2.16",
+  "version": "0.2.19",
   "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.16.md",
+    "docs/adr/0001-v0.3-offline-online-split.md",
+    "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",
     "LICENSE"

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

@@ -1,19 +1,13 @@
-import { dirname } from "node:path";
 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";
-
-const rootOf = (file) => {
-  const root = dirname(String(file || "").replace(/\\/g, "/"));
-  return root === "." ? "" : root;
-};
-const owns = (root, file) => !root || file === root || String(file || "").replace(/\\/g, "/").startsWith(`${root}/`);
+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: rootOf(file), ...parseCargoToml(readRepoText(boundary, 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);
@@ -29,7 +23,7 @@ export function collectCargoDependencyEvidence(repoRoot, { files = listRepoFiles
   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) => owns(scope.root, entry.file));
+    const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, entry.file));
     if (owner) importsByScope.get(owner).push(entry);
   }
   const findings = [], declared = new Set();

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/git-history/options.js

@@ -1,4 +1,5 @@
 import {isAbsolute} from 'node:path'
+import {boundedInteger} from '../../util.js'
 
 export const GIT_HISTORY_V = 1
 export const GIT_HISTORY_WINDOWS = Object.freeze([3, 6, 12])
@@ -28,10 +29,7 @@ export const roundHistoryNumber = (value, digits = 4) => {
     const scale = 10 ** digits
     return Math.round(value * scale) / scale
 }
-export const boundedHistoryInteger = (value, fallback, min, max) => {
-    const number = Number(value)
-    return Number.isInteger(number) ? Math.max(min, Math.min(max, number)) : fallback
-}
+export const boundedHistoryInteger = boundedInteger
 
 export function safeHistoryPath(value) {
     const path = String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')

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

@@ -1,25 +1,19 @@
-import { dirname } from "node:path";
 import { createRepoBoundary } from "../repo-path.js";
 import { computeGoDepFindings } from "./dep-check-ecosystems.js";
 import { listRepoFiles, readRepoText } from "./internal-audit.collect.js";
 import { parseGoMod } from "./manifests.js";
 import { makeFinding } from "./findings.js";
-
-const rootOf = (file) => {
-  const root = dirname(String(file || "").replace(/\\/g, "/"));
-  return root === "." ? "" : root;
-};
-const owns = (root, file) => !root || file === root || String(file || "").replace(/\\/g, "/").startsWith(`${root}/`);
+import { dependencyScopeOwnsFile, dependencyScopeRoot } from "./dependency/scoped-dependencies.js";
 
 export function collectGoDependencyEvidence(repoRoot, { files = listRepoFiles(repoRoot), externalImports = [], nonRuntimeRoots = [] } = {}) {
   const boundary = createRepoBoundary(repoRoot);
   const manifests = files.filter((file) => /(^|\/)go\.mod$/i.test(file));
-  const scopes = manifests.map((file) => ({ file, root: rootOf(file), parsed: parseGoMod(readRepoText(boundary, file)) }))
+  const scopes = manifests.map((file) => ({ file, root: dependencyScopeRoot(file), parsed: parseGoMod(readRepoText(boundary, file)) }))
     .sort((left, right) => right.root.length - left.root.length || left.root.localeCompare(right.root));
   const importsByScope = new Map(scopes.map((scope) => [scope, []]));
   for (const entry of externalImports) {
     if (entry.ecosystem !== "Go") continue;
-    const owner = scopes.find((scope) => owns(scope.root, entry.file));
+    const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, entry.file));
     if (owner) importsByScope.get(owner).push(entry);
   }
   const findings = [], declared = new Set(), issues = [];

package/src/analysis/hot-path-review.js

@@ -5,14 +5,12 @@ import {readCoverageForRepo, normalizeRepoParts} from './coverage-reports.js'
 import {computeStaticTestReachability} from './static-test-reachability.js'
 import {createPathClassifier, hasPathClass} from '../path-classification.js'
 import {isStructuralRelation} from '../graph/relations.js'
+import {boundedInteger} from '../util.js'
 
 const NON_PRODUCT = ['generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
 const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value || '')
 const normalize = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
-const boundedInt = (value, fallback, min, max) => {
-    const number = Number(value)
-    return Number.isInteger(number) ? Math.max(min, Math.min(max, number)) : fallback
-}
+const boundedInt = boundedInteger
 const round = (value) => Math.round(Number(value || 0) * 100) / 100
 const clamp = (value, min = 0, max = 100) => Math.max(min, Math.min(max, Number(value) || 0))
 

package/src/analysis/http-contracts/shared.js

@@ -1,3 +1,5 @@
+import { boundedInteger } from "../../util.js";
+
 export const HTTP_CONTRACTS_V = 2;
 export const HTTP_CONTRACT_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 
@@ -38,10 +40,7 @@ export function normalizeContractFile(value) {
   return normalized.split("/").some((part) => !part || part === "." || part === "..") ? "" : normalized;
 }
 
-export function boundedInteger(value, fallback, min, max) {
-  const number = Number(value);
-  return Number.isInteger(number) ? Math.max(min, Math.min(max, number)) : fallback;
-}
+export { boundedInteger };
 
 export function safeContractName(value, fallback) {
   const text = String(value || "").trim();

package/src/analysis/internal-audit/repo-files.js

@@ -12,15 +12,14 @@ export const readJson = (path) => {
     try { return JSON.parse(readFileSync(path, 'utf8')) } catch { return null }
 }
 
-export const readRepoText = (boundary, relativePath) => {
+const readRepoFile = (boundary, relativePath, reader) => {
     const resolved = boundary.resolve(relativePath)
-    return resolved.ok ? readText(resolved.path) : null
+    return resolved.ok ? reader(resolved.path) : null
 }
 
-export const readRepoJson = (boundary, relativePath) => {
-    const resolved = boundary.resolve(relativePath)
-    return resolved.ok ? readJson(resolved.path) : null
-}
+export const readRepoText = (boundary, relativePath) => readRepoFile(boundary, relativePath, readText)
+
+export const readRepoJson = (boundary, relativePath) => readRepoFile(boundary, relativePath, readJson)
 
 const SKIP_DIRS = new Set([
     '.git', '.hg', '.svn', 'node_modules', 'vendor', 'dist', 'build', 'coverage', '.next', 'out',

package/src/analysis/internal-audit.reach.js

@@ -118,6 +118,20 @@ export function entryFiles(graph, pkgOrScopes, dynamicTargets = new Set(), { dec
       if (target) entries.add(target);
     }
   }
+  // Drizzle Kit loads schema modules from configuration strings rather than a
+  // runtime import. Resolve the bounded `schema:` value so the schema and its
+  // exported tables are not reported as orphan/test-only production code.
+  for (const [rawFile, rawText] of sources || []) {
+    const configFile = String(rawFile || "").replace(/\\/g, "/");
+    if (!/(^|\/)drizzle(?:\.[^/]*)?\.config\.[cm]?[jt]s$/i.test(configFile)) continue;
+    const value = /\bschema\s*:\s*(\[[\s\S]{0,1000}?\]|["'][^"']+["'])/i.exec(String(rawText || ""))?.[1] || "";
+    const quoted = /["']([^"']+)["']/g;
+    let match;
+    while ((match = quoted.exec(value))) {
+      const candidate = posix.normalize(posix.join(posix.dirname(configFile), match[1].replace(/^\.\//, "")));
+      if (fileSet.has(candidate)) entries.add(candidate);
+    }
+  }
   for (const evidence of springConventionEntries(sources, fileSet)) {
     entries.add(evidence.file);
     conventionEvidence.push(evidence);

package/src/analysis/internal-audit.run.js

@@ -121,7 +121,7 @@ export async function runInternalAudit(repoPath, {
   ];
   const deadFileSet = new Set(dead.deadFiles.map((finding) => finding.file));
   for (const finding of structure.findings) {
-    if (!(finding.rule === "orphan-file" && deadFileSet.has(finding.file))) findings.push(finding);
+    if (!(finding.rule === "orphan-file" && (deadFileSet.has(finding.file) || entries.has(finding.file)))) findings.push(finding);
   }
 
   const actionableDeadFiles = dead.deadFiles.filter((finding) => !isNonProductPath(finding.file));
@@ -142,7 +142,7 @@ export async function runInternalAudit(repoPath, {
   }
   let unusedExportCount = 0;
   for (const symbol of unusedExports) {
-    if (symbol.test || isNonProductPath(symbol.file)) continue;
+    if (symbol.test || isNonProductPath(symbol.file) || entries.has(symbol.file) || dynamicTargets.has(symbol.file)) continue;
     if (/(^|\/)[^/]*\.config\.[a-z0-9]+$|(^|\/)\.[^/]+rc(\.[a-z]+)?$/i.test(symbol.file)) continue;
     findings.push(makeFinding({
       category: "unused",
@@ -159,7 +159,7 @@ export async function runInternalAudit(repoPath, {
     unusedExportCount++;
   }
   for (const symbol of dead.testOnlySymbols || []) {
-    if (isNonProductPath(symbol.file)) continue;
+    if (isNonProductPath(symbol.file) || entries.has(symbol.file) || dynamicTargets.has(symbol.file)) continue;
     findings.push(makeFinding({
       category: "unused",
       rule: "test-only-symbol",

package/src/analysis/manifests.js

@@ -99,55 +99,6 @@ export function parsePyprojectDeps(text) {
   return { present, deps };
 }
 
-// ---- poetry.lock → [{name, version, deps}] — [[package]] blocks + their [package.dependencies] keys ----
-export function parsePoetryLockDeps(text) {
-  const out = [];
-  let cur = null, inDeps = false;
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    const line = raw.trim();
-    if (line === "[[package]]") { cur = { name: "", version: "", deps: [] }; out.push(cur); inDeps = false; continue; }
-    if (line.startsWith("[")) { inDeps = cur != null && line === "[package.dependencies]"; if (line.startsWith("[[")) cur = null; continue; }
-    if (!cur) continue;
-    if (inDeps) { const m = line.match(/^["']?([A-Za-z0-9][\w.-]*)["']?\s*=/); if (m) cur.deps.push(m[1]); continue; }
-    let m = line.match(/^name\s*=\s*"([^"]+)"/); if (m && !cur.name) { cur.name = m[1]; continue; }
-    m = line.match(/^version\s*=\s*"([^"]+)"/); if (m && !cur.version) cur.version = m[1];
-  }
-  return out.filter((p) => p.name);
-}
-
-// ---- uv.lock → [{name, version, deps}] — [[package]] blocks with dependencies = [{ name = "x" }, …] ----
-export function parseUvLockDeps(text) {
-  const out = [];
-  let cur = null, inArr = false;
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    const line = raw.trim();
-    if (line === "[[package]]") { cur = { name: "", version: "", deps: [] }; out.push(cur); inArr = false; continue; }
-    if (line.startsWith("[") && !inArr) { if (line.startsWith("[[")) cur = null; continue; }
-    if (!cur) continue;
-    if (inArr) { for (const m of line.matchAll(/name\s*=\s*"([^"]+)"/g)) cur.deps.push(m[1]); if (/\]\s*$/.test(line)) inArr = false; continue; }
-    if (/^dependencies\s*=\s*\[/.test(line)) { for (const m of line.matchAll(/name\s*=\s*"([^"]+)"/g)) cur.deps.push(m[1]); inArr = !/\]\s*$/.test(line); continue; }
-    let m = line.match(/^name\s*=\s*"([^"]+)"/); if (m && !cur.name) { cur.name = m[1]; continue; }
-    m = line.match(/^version\s*=\s*"([^"]+)"/); if (m && !cur.version) cur.version = m[1];
-  }
-  return out.filter((p) => p.name);
-}
-
-// ---- installed dist-info METADATA → { name, version, deps, repository } (headers until the first blank
-// line; Requires-Dist entries gated behind `extra ==` markers are optional extras — skipped) ----
-export function parseDistMetadata(text) {
-  const out = { name: "", version: "", deps: [], repository: "" };
-  for (const raw of String(text || "").split(/\r?\n/)) {
-    if (raw.trim() === "") break;
-    let m = raw.match(/^Name:\s*(.+)$/i); if (m) { out.name = m[1].trim(); continue; }
-    m = raw.match(/^Version:\s*(.+)$/i); if (m) { out.version = m[1].trim(); continue; }
-    m = raw.match(/^Requires-Dist:\s*([A-Za-z0-9][\w.-]*)(.*)$/i);
-    if (m) { if (!/extra\s*==/.test(m[2])) out.deps.push(m[1]); continue; }
-    m = raw.match(/^(?:Home-page:\s*|Project-URL:\s*(?:Source|Repository|Homepage|Home|Code)[^,]*,\s*)(https?:\/\/\S+)/i);
-    if (m && !out.repository) out.repository = m[1];
-  }
-  return out;
-}
-
 // ---- Pipfile → { present, deps: [{name, dev}] } — [packages] / [dev-packages] table keys ----
 export function parsePipfileDeps(text) {
   const deps = [];

package/src/analysis/structure/dependency-graph.js

@@ -1,13 +1,8 @@
 import {ENTRY_FILE} from '../dead-check.js'
+import {fileOfId, graphEndpointId} from '../../graph/node-id.js'
 
 const TEST_FILE_RE = /(^|[/])(test|tests|__tests__|spec|e2e|__mocks__)([/]|$)|[._-](test|spec)\.[a-z0-9]+$/i
 const NON_CODE_RE = /\.(json|ya?ml|sh|ps1|md|txt|html?|css|scss|less)$|(^|[/])(dockerfile|containerfile)/i
-const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value)
-const fileOf = (value) => {
-    const id = endpoint(value)
-    const hash = id.indexOf('#')
-    return hash < 0 ? id : id.slice(0, hash)
-}
 const dirOf = (file) => file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
 
 export function buildFileImportGraph(graph, {includeTypeOnly = false, includeCompileOnly = false} = {}) {
@@ -23,7 +18,7 @@ export function buildFileImportGraph(graph, {includeTypeOnly = false, includeCom
     }
     for (const link of graph.links || []) {
         if (link.relation !== 'imports' && link.relation !== 're_exports') continue
-        const source = endpoint(link.source), target = endpoint(link.target)
+        const source = graphEndpointId(link.source), target = graphEndpointId(link.target)
         if (!fileIds.has(source) || !fileIds.has(target) || source === target) continue
         if (source.endsWith('.go') && target.endsWith('.go') && dirOf(source) === dirOf(target)) continue
         const key = `${source}\0${target}`
@@ -112,7 +107,7 @@ export function findOrphans(graph, {entrySet = new Set(), externalImportFiles =
     const degree = new Map()
     for (const link of graph.links || []) {
         if (link.relation === 'contains') continue
-        const source = fileOf(link.source), target = fileOf(link.target)
+        const source = fileOfId(graphEndpointId(link.source)), target = fileOfId(graphEndpointId(link.target))
         if (source === target) continue
         degree.set(source, (degree.get(source) || 0) + 1)
         degree.set(target, (degree.get(target) || 0) + 1)

package/src/graph/internal-builder.langs.js

@@ -115,6 +115,25 @@ function gitFileUniverse(dir) {
     });
   } catch { return null; }
 
+  // `git -C <dir>` also succeeds when <dir> is merely nested under some parent repository. If that
+  // nested directory is ignored by the parent, `ls-files` is empty even though <dir> can be a valid
+  // standalone repository root selected by the user (or a repository staged by a test/tool). In
+  // that one ambiguous case, fall back to the boundary-safe walker. Preserve an empty universe for
+  // an actual Git root so ignored files do not leak back into its graph.
+  if (!raw) {
+    try {
+      const top = execFileSync("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 15_000,
+        maxBuffer: 1024 * 1024,
+        env: childProcessEnv(),
+      }).trim();
+      if (realpathSync.native(top) !== realpathSync.native(dir)) return null;
+    } catch { return null; }
+  }
+
   let rootReal;
   try { rootReal = realpathSync.native(dir); } catch { return null; }
   const files = [];

package/src/graph/node-id.js

@@ -0,0 +1,7 @@
+export const graphEndpointId = (value) => String(value && typeof value === "object" ? value.id : value);
+
+export const fileOfId = (value) => {
+  const id = String(value || "");
+  const hash = id.indexOf("#");
+  return hash < 0 ? id : id.slice(0, hash);
+};

package/src/mcp/architecture-bootstrap.mjs

@@ -49,13 +49,13 @@ function materializeCandidate(candidate, verification, baselineMode) {
     })
 }
 
-function activeContract(ctx) {
+export function activeArchitectureContract(ctx) {
     if (!ctx?.repoRoot) return {contract: null, source: null, error: 'no repository root is active'}
     return loadArchitectureContract(ctx.repoRoot, ctx.graphPath)
 }
 
 function preview(g, args, ctx) {
-    const active = activeContract(ctx)
+    const active = activeArchitectureContract(ctx)
     if (active.contract) return toolResult(
         `Architecture bootstrap refused: an active contract already exists at ${active.source}.`,
         {state: 'ALREADY_CONFIGURED', source: active.source, contractHash: active.contract.contractHash},
@@ -122,7 +122,7 @@ function approve(g, args, ctx) {
             state: 'REPOSITORY_CHANGED', wrote: false,
         })
     }
-    const active = activeContract(ctx)
+    const active = activeArchitectureContract(ctx)
     if (active.contract || active.error) return toolResult(
         `Architecture approval refused: ${active.source || 'a contract'} appeared or changed after preview.`,
         {state: active.error ? 'ERROR' : 'ALREADY_CONFIGURED', wrote: false, source: active.source, error: active.error || undefined},

package/src/mcp/evidence-snapshot.common.mjs

@@ -83,9 +83,7 @@ export function moduleId(value) {
 }
 
 export function nonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0
-        ? Math.trunc(value)
-        : 0
+    return optionalNonNegativeInteger(value) ?? 0
 }
 
 export function optionalNonNegativeInteger(value) {

package/src/mcp/evidence-snapshot.health.mjs

@@ -3,6 +3,8 @@ import {
     normalizeCheckState, numericRecord, optionalNonNegativeInteger, privacySafeText, repoRelativePath,
     sanitizeFinding,
 } from './evidence-snapshot.common.mjs'
+import {summarizeFindings} from '../analysis/findings.js'
+import {auditFindingPathScope} from './health/audit-format.mjs'
 
 function buildHotspots(graph) {
     let analyzed = 0
@@ -40,7 +42,7 @@ function buildHotspots(graph) {
     return {analyzed, ...bounded(facts, CAPS.hotspots)}
 }
 
-export function buildHealthSection(graph, audit) {
+export function buildHealthSection(graph, audit, repoRoot = null) {
     if (!audit?.ok) {
         return {
             state: STATE.ERROR,
@@ -52,7 +54,12 @@ export function buildHealthSection(graph, audit) {
             complexity: {thresholds: COMPLEXITY_THRESHOLDS, analyzed: 0, hotspots: []},
         }
     }
-    const findings = bounded((audit.findings || []).map(sanitizeFinding).filter(Boolean)
+    // Public/private hosted evidence follows the same production-first path policy as
+    // run_audit. Classified-only findings remain available locally through
+    // include_classified:true, but must not turn a hosted production snapshot red.
+    const scopedFindings = auditFindingPathScope(audit.findings, {repoRoot}).findings
+    const scopedSummary = summarizeFindings(scopedFindings)
+    const findings = bounded(scopedFindings.map(sanitizeFinding).filter(Boolean)
         .sort((a, b) => compareText(a.severity, b.severity) || compareText(a.category, b.category) ||
             compareText(a.rule, b.rule) || compareText(a.file || a.package || '', b.file || b.package || '') || compareText(a.id, b.id)),
     CAPS.findings)
@@ -76,8 +83,8 @@ export function buildHealthSection(graph, audit) {
             reasons: state === STATE.PARTIAL ? ['OPTIONAL_CHECKS_INCOMPLETE'] : [],
         },
         summary: {
-            bySeverity: numericRecord(audit.summary?.bySeverity, ['critical', 'high', 'medium', 'low', 'info']),
-            byCategory: numericRecord(audit.summary?.byCategory, ['unused', 'structure', 'vulnerability', 'malware']),
+            bySeverity: numericRecord(scopedSummary.bySeverity, ['critical', 'high', 'medium', 'low', 'info']),
+            byCategory: numericRecord(scopedSummary.byCategory, ['unused', 'structure', 'vulnerability', 'malware']),
             dead: numericRecord(audit.deadReport, ['deadSymbols', 'deadFiles', 'unusedExports']),
             structure: numericRecord(audit.structureReport, [
                 'runtimeImportEdges', 'typeOnlyImportEdges', 'compileOnlyImportEdges', 'runtimeCycles',

package/src/mcp/evidence-snapshot.mjs

@@ -35,7 +35,7 @@ export async function createEvidenceSnapshot({repoRoot, graph}) {
     const sections = {
         architecture: buildArchitectureSection(inputGraph, aggregate, audit, structure),
         duplicates: buildDuplicatesSection(repoRoot, inputGraph),
-        health: buildHealthSection(inputGraph, audit),
+        health: buildHealthSection(inputGraph, audit, repoRoot),
         technologies: buildTechnologiesSection(stack, stackError),
         packages: buildPackagesSection(installedResult, installedError, inputGraph, audit, repoRoot),
     }

package/src/mcp/graph-diff.mjs

@@ -2,6 +2,7 @@
 import {buildFileImportGraph, findSccs} from '../analysis/dep-rules.js'
 import {folderModuleOf} from '../analysis/graph-analysis.aggregate.js'
 import {isStructuralRelation} from '../graph/relations.js'
+import {fileOfId} from '../graph/node-id.js'
 
 // ---- graph diff ----------------------------------------------------------------------------------
 // One previous state is enough (4-13 MB per repo — cheap): rebuild_graph snapshots the outgoing
@@ -10,7 +11,7 @@ import {isStructuralRelation} from '../graph/relations.js'
 // the signal is aggregated: module-dependency drift, cycle count changes, newly orphaned symbols.
 export const prevGraphPathFor = (graphPath) => String(graphPath).replace(/\.json$/, '.prev.json')
 export const edgeEndpoint = (v) => String(v && typeof v === 'object' ? v.id : v)
-export const fileOfId = (id) => { const s = String(id); const h = s.indexOf('#'); return h < 0 ? s : s.slice(0, h) }
+export {fileOfId}
 const folderOfFile = folderModuleOf
 
 const terminalLineSuffix = (id) => {

package/src/mcp/tools-architecture.mjs

@@ -1,6 +1,6 @@
 // Executable target architecture for agents: read the active contract before a change, then run the
 // same deterministic verifier after it. No tool silently edits policy or accepts debt.
-import {contractForChange, loadArchitectureContract, normalizeArchitectureContract, verifyArchitecture} from '../analysis/architecture-contract.js'
+import {contractForChange, normalizeArchitectureContract, verifyArchitecture} from '../analysis/architecture-contract.js'
 import {createPathClassifier, hasPathClass} from '../path-classification.js'
 import {detectRepoStack} from '../scan/discover.js'
 import {toolResult} from './tool-result.mjs'
@@ -13,6 +13,7 @@ const [starter, bootstrap] = await Promise.all([
 ])
 const {createArchitectureStarter, PROVISIONAL_BUDGETS} = starter
 export const tBootstrapArchitecture = bootstrap.tBootstrapArchitecture
+const activeContract = bootstrap.activeArchitectureContract
 
 const remediation = () => ({
     offlinePath: '.weavatrix/architecture.json',
@@ -29,11 +30,6 @@ const stackIds = (repoRoot) => {
     } catch { return [] }
 }
 
-function activeContract(ctx) {
-    if (!ctx?.repoRoot) return {contract: null, source: null, error: 'no repository root is active'}
-    return loadArchitectureContract(ctx.repoRoot, ctx.graphPath)
-}
-
 function notConfiguredResult(g, action, {includeStarter = false, repoRoot = null} = {}) {
     const proposal = includeStarter ? createArchitectureStarter(g, repoRoot) : null
     const starter = proposal?.contract || null

package/src/mcp/tools-impact-change.mjs

@@ -2,6 +2,7 @@
 // classifier/evidence contract can be tested without perturbing get_dependents or graph_diff.
 import {spawnSync} from 'node:child_process'
 import {childProcessEnv} from '../child-env.js'
+import {fileOfId} from '../graph/node-id.js'
 import {classifyChangeImpact} from '../analysis/change-classification.js'
 import {readCoverageForRepo} from '../analysis/coverage-reports.js'
 import {computeStaticTestReachability} from '../analysis/static-test-reachability.js'
@@ -29,12 +30,6 @@ const impactKind = (entry) => entry?.runtimeDepth != null
     ? (entry.compileDepth != null ? `runtime + compile-time(d${entry.compileDepth})` : 'runtime')
     : 'compile-time'
 
-const fileOfNode = (id) => {
-    const value = String(id)
-    const hash = value.indexOf('#')
-    return hash < 0 ? value : value.slice(0, hash)
-}
-
 const partialResult = (text, reason, status = 'UNAVAILABLE') => toolResult(text, {
     status,
     verdict: 'HIGH',
@@ -105,8 +100,8 @@ export function tChangeImpactV2(g, args = {}, ctx = {}) {
     const cap = Math.max(5, Math.min(120, Number(args.max_nodes) || 40))
     const reached = seeds.size ? reverseReach(g, seeds, maxDepth) : new Map()
     const impacted = [...reached.entries()]
-        .filter(([id]) => !seeds.has(id) && !changedSet.has(fileOfNode(id)))
-        .map(([id, entry]) => ({id, depth: entry.depth, entry, degree: degreeOf(g, id), file: fileOfNode(id)}))
+        .filter(([id]) => !seeds.has(id) && !changedSet.has(fileOfId(id)))
+        .map(([id, entry]) => ({id, depth: entry.depth, entry, degree: degreeOf(g, id), file: fileOfId(id)}))
         .sort((left, right) => left.depth - right.depth
             || Number(left.entry.compileOnly) - Number(right.entry.compileOnly)
             || right.degree - left.degree

package/src/security/malware-scoring.js

@@ -22,6 +22,10 @@ function addTyposquatCoSignals(byPkg) {
 function visibleSignals(signals, allow) {
   const kept = signals.filter((s) => !(allow && s.noisy));
   if (!kept.length) return [];
+  // A literal URL, or even a network call to one, is ordinary package behavior without a second
+  // security signal. Keep those weak observations available as co-evidence (for example beside
+  // environment harvesting), but never create a standalone malware finding from them.
+  if (!kept.some((s) => !s.weak)) return [];
   const hasStrongerUrl = kept.some((s) => STRONG_URL_KEYS.has(s.key));
   return hasStrongerUrl ? kept.filter((s) => s.key !== "hardcoded-url") : kept;
 }

package/src/security/registry-sig.rules.js

@@ -90,6 +90,7 @@ export const CONTENT_RULES = [
     severity: "low",
     nearZeroFp: false,
     noisy: true,
+    weak: true,
     pattern: "(fetch|axios\\.|XMLHttpRequest|sendBeacon|https?\\.request|request\\(|curl\\b|wget\\b).{0,220}https?://",
     re: new RegExp(`\\b(fetch|axios\\.(get|post|put|patch|request)|XMLHttpRequest|sendBeacon|https?\\.request|http\\.request|request\\(|curl\\b|wget\\b)[\\s\\S]{0,220}?${PLAIN_EXTERNAL_URL}`, "i"),
     what: "network call to hardcoded external URL",
@@ -172,9 +173,9 @@ export const CONTENT_RULES = [
     key: "hidden-unicode",
     severity: "medium",
     nearZeroFp: false,
-    pattern: "[\\x{202A}-\\x{202E}\\x{2066}-\\x{2069}\\x{FE00}-\\x{FE0F}]",
-    re: new RegExp("\\u202A|\\u202B|\\u202C|\\u202D|\\u202E|\\u2066|\\u2067|\\u2068|\\u2069|\\uFE00|\\uFE01|\\uFE02|\\uFE03|\\uFE04|\\uFE05|\\uFE06|\\uFE07|\\uFE08|\\uFE09|\\uFE0A|\\uFE0B|\\uFE0C|\\uFE0D|\\uFE0E|\\uFE0F", "u"),
-    what: "hidden Unicode control/variation character in package source",
+    pattern: "[\\x{202A}-\\x{202E}\\x{2066}-\\x{2069}]",
+    re: new RegExp("\\u202A|\\u202B|\\u202C|\\u202D|\\u202E|\\u2066|\\u2067|\\u2068|\\u2069", "u"),
+    what: "hidden bidirectional Unicode control character in package source",
   },
   {
     key: "obfuscated-code",

package/src/security/typosquat.js

@@ -31,7 +31,9 @@ const KNOWN_LEGIT = new Set([
   "markdown-it", "babel-loader", "css-loader", "style-loader", "query-string",
 ]);
 
-const norm = (name) => String(name || "").toLowerCase().replace(/^@[^/]+\//, ""); // drop scope for the compare
+const rawName = (name) => String(name || "").trim().toLowerCase();
+const isScoped = (name) => /^@[^/]+\/.+/.test(name);
+const unscopedTail = (name) => name.replace(/^@[^/]+\//, "");
 
 // Damerau-Levenshtein (optimal string alignment) — includes adjacent transposition.
 export function damerau(a, b) {
@@ -56,12 +58,19 @@ export function damerau(a, b) {
 // Threshold: distance 1 always; distance 2 only for names ≥8 chars (short names collide too easily).
 // Skip: exact popular names, known-legit pairs, names <4 chars.
 export function classifyTyposquat(name) {
-  const raw = String(name || "");
-  const n = norm(raw);
-  if (n.length < 4 || TOP_PACKAGES.has(raw) || TOP_PACKAGES.has(n) || KNOWN_LEGIT.has(raw) || KNOWN_LEGIT.has(n)) return null;
+  const raw = rawName(name);
+  const scoped = isScoped(raw);
+  const tail = unscopedTail(raw);
+  // A package scope is an ownership boundary, not punctuation to discard.
+  // Comparing every scoped basename with unscoped popular names made the
+  // official @playwright/test package look like a one-edit misspelling of jest.
+  if (tail.length < 4 || TOP_PACKAGES.has(raw) || TOP_PACKAGES.has(tail)
+    || KNOWN_LEGIT.has(raw) || KNOWN_LEGIT.has(tail)) return null;
+  const candidates = [...TOP_PACKAGES].filter((top) => isScoped(top) === scoped);
+  const n = scoped ? raw : tail;
   let best = null;
-  for (const top of TOP_PACKAGES) {
-    const t = norm(top);
+  for (const top of candidates) {
+    const t = rawName(top);
     if (t === n) return null; // scope-only difference of a popular name → not a squat
     const dist = damerau(n, t);
     if (dist === 0) return null;

package/src/util.js

@@ -24,6 +24,11 @@ export function lineNumberAt(text, index) {
   return line;
 }
 
+export function boundedInteger(value, fallback, min, max) {
+  const number = Number(value);
+  return Number.isInteger(number) ? Math.max(min, Math.min(max, number)) : fallback;
+}
+
 export function safeRead(path) {
   try {
     const st = statSync(path);

package/docs/releases/v0.2.16.md

@@ -1,53 +0,0 @@
-# Weavatrix 0.2.16
-
-0.2.16 is a semantic-precision, dependency-coverage, and cross-transport contract release. It keeps
-the 38-tool MCP surface and local-first defaults while fixing the critical case where a safe
-TypeScript project plugin could disable every exact reference edge.
-
-## Exact dependents for real TypeScript projects
-
-- TypeScript project plugins such as Next.js are recorded and suppressed instead of making the
-  semantic overlay unavailable. Repository-local plugin code is never loaded.
-- `get_dependents` performs a bounded exact point query for JS/TS symbols by default. A complete LSP
-  result replaces heuristic direct references; an incomplete result retains graph evidence and says
-  why.
-- `change_impact` batches exact direct-reference queries for changed JS/TS symbols. Transitive hops
-  remain explicitly graph-backed instead of being presented as LSP proof.
-- Real-repository validation moved an affected Next.js repository from `UNAVAILABLE / 0 EXACT_LSP`
-  to a bounded partial overlay with 154 exact edges; a point query outside the initial budget found
-  16 exact direct references and then served the same result from cache.
-
-## Multi-ecosystem dependency and advisory evidence
-
-- Python checks nested requirements, pyproject/Poetry/Pipfile scopes; Go resolves nested modules,
-  direct/indirect requirements and replacements; both compare declarations with indexed imports.
-- Maven resolves properties and dependency declarations; Gradle resolves common Groovy/Kotlin
-  declarations, version catalogs and lock evidence. Import-to-artifact mapping uses bounded group
-  prefixes and artifact tokens and keeps reflection/generated/runtime-only cases review-only.
-- Cargo resolves workspace inheritance, renamed packages and lockfile pins, compares crate paths to
-  the nearest manifest, and reports feature/proc-macro uncertainty rather than claiming compiler
-  proof.
-- Explicit advisory refresh now includes concrete Maven and crates.io pins in addition to npm,
-  PyPI and Go. It remains opt-in and sends only package identities and versions to OSV.
-
-## Contracts beyond static HTTP
-
-- `trace_api_contract` can select HTTP, GraphQL, gRPC or event contracts. Static GraphQL
-  operations/schema fields, proto service methods/stub calls and Kafka/event topics join across
-  registered local repositories.
-- Runtime-computed URLs, operations/topics, reflection and dynamic stubs remain `UNKNOWN` with
-  bounded evidence. Runtime configuration is never converted into a false clean result.
-
-## Agent and Hosted fixes
-
-- Package metadata now names Codex/OpenAI Codex alongside other MCP and coding-agent workflows.
-- The Hosted Flow view distinguishes an aggregate folder-boundary feedback loop from a proven
-  file-level runtime import cycle. Current Weavatrix evidence has zero file-level runtime cycles.
-- The release checklist includes a fresh preview-confirmed private graph sync, so public demo history
-  and authenticated repository maps cannot silently drift apart.
-
-## Verification
-
-The release is gated by the full Node suite, six-language fixture benchmark, real-repository
-semantic checks, exact LSP dogfooding, release-manifest verification, packed npm and MCPB stdio
-checks, npm audit, Hosted tests/build/lint, explicit private sync, and live browser verification.