weavatrix 0.2.11 → 0.2.13

package/README.md

@@ -49,6 +49,100 @@ Weavatrix answers questions a text index cannot:
   impact, bounded call-argument flow, Git graph drift, architecture/duplicate/API ratchets, and
   affected-test evidence.
 
+## Worked examples
+
+These are representative sequences from local dogfooding, not fabricated chat transcripts. Counts
+describe the observed repository snapshots and will move with the code.
+
+### Understand an unfamiliar backend without reading it linearly
+
+```text
+Question: Where does an attack-mitigation request go?
+
+module_map
+  -> production territories and strongest module dependencies
+list_endpoints
+  -> 462 routes observed in a 1,076-file backend snapshot
+trace_endpoint
+  -> composed router mount -> controller -> service -> task/messaging
+  -> bounded call-site excerpts around decisive edges
+```
+
+Use `module_map` for the initial application shape, then switch to the exact endpoint or symbol. Do
+not lead with a broad natural-language `query_graph` when the route or identifier is already known.
+
+### Check whether a backend handler is used by another repository
+
+```text
+Question: Can this handler be removed?
+
+list_known_repos -> trace_api_contract
+  backend endpoints observed: 163
+  client callsites joined:     267 across two registered clients
+  handler liveness:            NOT_DEAD_EXTERNAL_USE
+  unresolved dynamic URLs:     POSSIBLE_EXTERNAL_USE / UNKNOWN
+```
+
+This joins separately cached local graphs; it does not upload source. Medium/high-confidence
+external use can keep a handler out of the dead-code queue, while dynamic or ambiguous calls remain
+explicitly incomplete evidence.
+
+### Change one method with an evidence trail
+
+```text
+inspect_symbol -> context_bundle -> get_dependents -> coverage_map
+  -> edit the bounded workset
+  -> verified_change phase=verify base_ref=<merge-base>
+```
+
+On an observed BranchPilot diff, `change_impact` separated removed methods/signatures from additive
+exports and ranked a 98-node radius without collapsing runtime and type-only coupling. If measured
+coverage, the architecture contract, or requested tests are missing, the final state is `UNKNOWN`,
+not a cosmetic pass.
+
+### Review Health and clone debt without auto-deleting code
+
+```text
+run_audit category=dependencies debt=all
+  -> missing direct dependency (observed: mongodb)
+  -> lockfile drift and unresolved imports
+run_audit debt=all
+  -> runtime cycles separated from compile/type-only coupling
+find_duplicates
+  -> clone families and same-name divergence
+  -> homogeneous router boilerplate suppressed by default
+```
+
+Every dead-code, orphan, dependency and duplicate item remains review evidence. Confirm framework
+conventions and source use before editing; Weavatrix does not auto-delete or merge findings.
+
+## Benchmarks
+
+Two different gates ship in the repository:
+
+- `npm run benchmark` is a reproducible golden suite for TypeScript, JavaScript, Python, Go, Java
+  and Rust, plus cross-repository HTTP matching, framework conventions and the MCP graph lifecycle.
+- `npm run benchmark:real` compares revision-pinned local application snapshots with the checked-in
+  0.2.1 relation baseline. It fails on unexplained signal loss; `MISSING`, `STALE` and `UNBASELINED`
+  remain incomplete, not green.
+
+Latest local release run (Windows x64, Node 24.15.0, July 18, 2026):
+
+| Gate | Result | Selected evidence |
+|---|---:|---|
+| Six language fixtures | 6/6 PASS | exact symbols/edges and complete edge provenance |
+| Cross-repo fixture | PASS, 431.79 ms cold | endpoint match, typed wrapper, external use, affected screen |
+| Lifecycle | PASS | `full -> incremental -> none -> reconnect/none`; 1,376-byte text response |
+| Total fixture cold build | 1.31 s | all six language graphs; 6.4 KB bounded report |
+| Real-repository baseline | 6/6 PASS | TS, JS, Python, Go, Java and Rust snapshots |
+
+Real snapshots ranged from 473 nodes / 1,165 edges in 0.22 s (Go) to 8,192 nodes / 21,814 edges
+in 9.44 s (TypeScript). The Java snapshot built 7,143 nodes / 23,708 edges in 2.61 s, including
+receiver-aware cross-file calls. These are regression measurements on one machine, not competitor
+benchmarks or universal latency claims. See [benchmark/cases.mjs](benchmark/cases.mjs),
+[benchmark/real-repositories.json](benchmark/real-repositories.json), and run the commands above to
+reproduce them on your own repositories.
+
 ## Quick start
 
 Requires Node ≥ 18. One command:
@@ -100,6 +194,13 @@ Advanced registrations may still pass an exact comma-separated capability set:
 a compatibility alias for `advisories,hosted`; new registrations should use the named profiles or
 the narrower capability names.
 
+After an upgrade, reconnect the MCP server or start a new agent task before checking its tool list:
+many clients snapshot `tools/list` and input schemas for the lifetime of one connection. The expected
+counts are 31 for `pinned`, 34 for `offline`, 35 for `osv`, and all 38 for `hosted` / `full`. A custom
+capability list must include `crossrepo` to expose `trace_api_contract`; `online` alone adds only the
+legacy advisory/Hosted groups. `graph_stats` reports the running package version, enabled capabilities
+and registered-tool count so a cached process can be distinguished from the installed package.
+
 Or clone it:
 
 ```sh
@@ -248,6 +349,24 @@ reconnect. Every MCP response also carries local, transient `_meta["weavatrix/me
 time, output bytes/token estimate, graph freshness/revision/update and graph-cache status. These
 metrics are not persisted or transmitted by Weavatrix.
 
+### 0.2.13 runtime-integrity and cross-language verification patch
+
+- `verified_change` no longer requires `package.json` when no package tests can run. Python, Go,
+  Java, Rust and other non-Node repositories now receive `NOT_REQUESTED` or `DISABLED` test evidence
+  instead of a false `BLOCKED`; actual package-script execution keeps the same double opt-in and
+  allowlist.
+- Release verification starts the packed npm artifact and portable MCPB stage over stdio. It asserts
+  the exact profile counts and required 38-tool `full` surface, including `trace_endpoint`,
+  `trace_api_contract` and `preview_sync`, so source/package drift cannot publish silently.
+- Runtime diagnostics expose the package version, selected capability groups and registered tool
+  count. The documentation now distinguishes an old client connection from an intentional profile
+  omission and explains that custom capabilities need `crossrepo` for contract tracing.
+- The bundled skill documents practical CLI/worker/event flows, local target-architecture adoption,
+  repository classification, undirected path semantics and the correct release and proof-carrying
+  change recipes without reducing Weavatrix to text search.
+
+Full patch notes: [docs/releases/v0.2.13.md](docs/releases/v0.2.13.md).
+
 ### 0.2.9 correctness, signal, and consent patch
 
 - Express endpoint inventory composes nested imported `router.use(...)` mounts, so a local route such

package/docs/releases/v0.2.13.md

@@ -0,0 +1,48 @@
+# Weavatrix 0.2.13
+
+## Runtime-integrity and cross-language verification patch
+
+0.2.13 closes two failures found by dogfooding the live MCP on real JavaScript and Python
+applications. A live client could keep an older tool/schema snapshot after the checkout had advanced,
+and `verified_change` treated the absence of a Node manifest as a blocker even when no package test
+was requested. Neither failure is converted into a cosmetic pass: incomplete architecture, coverage,
+API or test evidence still produces `UNKNOWN` where appropriate.
+
+### Cross-language `verified_change`
+
+- An empty test request returns `NOT_REQUESTED` before looking for `package.json`.
+- Requested package tests with `run_tests:false` return `DISABLED` without pretending that they ran
+  or blocking a Python/Go/Java/Rust repository for lacking an npm manifest.
+- Actual execution still requires both `run_tests:true` and `WEAVATRIX_ALLOW_TEST_RUNS=1`, accepts
+  only existing test/check/verify package scripts and rejects shell-sensitive arguments.
+- Regression coverage exercises both plan and verify phases against a Python-only repository.
+
+### Packed-runtime and live-tool integrity
+
+- Release verification runs the packed npm artifact and portable MCPB stage as real stdio servers.
+- The smoke gate asserts 34 tools for the offline profile and all 38 for `hosted` / `full`, including
+  `trace_endpoint`, `trace_api_contract` and the local-only `preview_sync` approval step.
+- `graph_stats` and initialization diagnostics identify the running package version, enabled
+  capabilities and registered tool count. This separates an old client connection from a deliberately
+  restricted profile.
+- Existing security boundaries are unchanged: `offline` remains the no-HTTP default; `online` stays
+  a compatibility alias for `advisories,hosted`; `crossrepo` is not silently added to a custom list;
+  and no network tool is made available by default.
+
+MCP clients commonly snapshot `tools/list` for one connection. After upgrading, reconnect or start a
+new task. Expected counts are 31 (`pinned`), 34 (`offline`), 35 (`osv`) and 38 (`hosted` / `full`).
+
+### Skill and architecture workflow
+
+The bundled skill now covers non-HTTP entrypoints (CLI, worker, queue, cron and events), explains how
+to review and save a local starter contract, establish an explicit ratchet baseline, apply a reviewed
+exception, and classify generated/test/resource trees through `.weavatrix.json`. It also labels
+`shortest_path` as undirected connectivity rather than directional call proof, uses the correct
+`change_impact base` parameter, and avoids redundant symbol-context calls.
+
+## Compatibility
+
+- The 38 tool names, input schemas and `weavatrix.tool.v1` result envelope remain compatible.
+- Hosted sync payload v2/v3, confirmation-token consent and architecture-contract transport are
+  unchanged; no hosted application change is required.
+- The public MIT license and local-first network boundary are unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "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,7 @@
     "skill",
     "scripts/run-agent-task-benchmark.mjs",
     "docs/agent-task-benchmark.md",
-    "docs/releases/v0.2.11.md",
+    "docs/releases/v0.2.13.md",
     "README.md",
     "SECURITY.md",
     "LICENSE"

package/skill/SKILL.md

@@ -16,15 +16,20 @@ Tools are named `mcp__weavatrix__…`. If none are available, ask the user to re
 (`claude mcp add -s user weavatrix -- npx -y weavatrix <repoRoot>`; Codex:
 `codex mcp add weavatrix -- npx -y weavatrix <repoRoot>`), then retry.
 
-If `refresh_advisories`, `preview_sync`, `pull_architecture_contract`, or `sync_graph` is missing, do not diagnose a
-broken installation: network tools are intentionally absent from `offline` and `pinned`.
+First compare the selected profile with the `graph_stats` runtime line. Expected catalogs are 31
+tools for `pinned`, 34 for `offline`, 35 for `osv`, and 38 for `hosted` / `full`. If the running
+version/count differs from the installed package, or local tools such as `trace_endpoint` are missing,
+reconnect/start a new agent task because clients commonly cache `tools/list` for one connection. A
+custom capability list needs `crossrepo` for `trace_api_contract`; legacy `online` adds only
+`advisories,hosted`. Missing HTTP tools are intentional only when the selected profile excludes them.
 
 Profiles use the same npm package and binary:
 
 - `offline` (default): all local analysis and explicit `open_repo`; no HTTP tools.
 - `pinned`: local analysis with no `open_repo`, no global/cross-repository graph access, and no HTTP tools.
 - `osv`: `offline` plus explicit `refresh_advisories`.
-- `hosted` / `full`: `osv` plus local-only `preview_sync`, `pull_architecture_contract` and `sync_graph`.
+- `hosted` / `full`: `osv` plus local-only `preview_sync` and the explicitly invoked network tools
+  `pull_architecture_contract` and confirmed `sync_graph`.
 
 The legacy `online` capability remains a compatibility alias for `advisories,hosted`; prefer the
 named profiles for new registrations.
@@ -45,7 +50,9 @@ projection; expand only when the answer requires it.
 - **Find high-coupling hubs**: `god_nodes`; repeated call sites do not inflate unique connectivity.
 - **Inspect one graph entity**: `get_node`; pass an exact node ID when labels are ambiguous.
 - **Inspect direct one-hop relations**: `get_neighbors`; do not confuse it with transitive impact.
-- **Prove a path between two concepts**: `shortest_path`.
+- **Find a connectivity path between two concepts**: `shortest_path`. It traverses the graph as
+  undirected reachability, so it is not proof of call/dependency direction; confirm direction with
+  `get_neighbors` and `read_source`.
 - **Explore an unknown entry point or architectural question**: `query_graph`; pin `seed_files` when
   known, and keep its broad result as orientation evidence.
 - **Inspect one exact symbol deeply**: `context_bundle` for the bounded edit workset;
@@ -59,16 +66,23 @@ projection; expand only when the answer requires it.
 - **Trace one endpoint through the application**: `trace_endpoint` for route -> handler -> bounded
   downstream call flow with edge-centered excerpts.
 - **Trace an API contract across repositories**: `list_known_repos` -> `trace_api_contract` with an
-  explicit backend/client set; inspect each graph reconciliation state before using the verdict.
+  explicit backend/client set; prefer this over separate per-repository endpoint/search passes when
+  a backend change may affect registered clients, and inspect each graph reconciliation state before
+  using the verdict.
 - **Measure one symbol's transitive blast radius**: `get_dependents`.
-- **Review the current branch, diff, or external patch**: `change_impact`.
+- **Review the current branch, diff, or external patch**: `change_impact`; its explicit baseline
+  parameter is `base`, not the `base_ref` used by audit/diff/verification tools. It distinguishes
+  additive exports from signature/body/removal risk and separates runtime/type-only radius plus
+  available measured coverage or explicitly static reachability.
 - **Compare structural graph revisions**: `graph_diff base_ref=<merge-base>` for module edges, cycles,
   orphans and lost callers; without `base_ref`, compare the last rebuild snapshots.
 - **Use behavioral history**: `git_history` for churn x connectivity, hidden co-change and expected
   test/source coupling from bounded local Git numstat evidence.
-- **Plan and verify a serious change or pre-commit gate**: `verified_change phase=plan` -> edit ->
-  `verified_change phase=verify base_ref=<same-ref>`. It composes exact context, impact, graph,
-  architecture, duplicate, optional API and test proof into one PASS/BLOCKED/UNKNOWN envelope.
+- **Plan and verify a serious change or pre-commit gate**:
+  `verified_change task=<same-task> phase=plan base_ref=<merge-base>` -> edit ->
+  `verified_change task=<same-task> phase=verify base_ref=<same-ref>`. It composes exact context, impact, graph,
+  architecture, duplicate, optional API and test proof into one PASS/BLOCKED/UNKNOWN envelope. It is
+  a proof layer around an agent's edit, not a source editor or hidden auto-fix.
 
 ### Health, debt and testing scenarios
 
@@ -96,7 +110,8 @@ projection; expand only when the answer requires it.
 - **Select rules before editing**: `prepare_change`; **enforce the ratchet after editing**:
   `verify_architecture`.
 - **Understand or request an exception**: `explain_architecture_violation` ->
-  `propose_architecture_exception`; proposals never mutate policy automatically.
+  `propose_architecture_exception`; proposals never mutate policy automatically. After human approval,
+  the owner must add the returned proposal to the local contract's `exceptions` or approve it in Hosted.
 - **Pull an owner-approved Hosted target**: `pull_architecture_contract` only in an explicitly enabled
   Hosted profile.
 - **Review exactly what Hosted sync would send**: `preview_sync`; only an approved
@@ -110,6 +125,9 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
 
 ## Ground rules
 
+- **No hidden source mutation**: Weavatrix builds derived graph/cache artifacts and can run explicitly
+  authorized tests, but it does not edit repository source, auto-delete debt, merge clones, or rewrite
+  architecture policy. The coding agent remains responsible for the change and its tests.
 - **Evidence, not verdicts**: treat audit, hub, orphan and duplicate output as hypotheses. Confirm a
   finding in source and check framework/runtime conventions before deleting, merging or redesigning
   code. A same-name/different-body pair is a divergence candidate, not proof of duplication.
@@ -187,16 +205,19 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
 
 ## Recipes
 
-- **Proof-carrying refactor**: `verified_change task="..." phase=plan base_ref=<merge-base>` -> edit ->
-  `verified_change task="..." phase=verify base_ref=<same-ref> tests=[{"script":"test","args":[...]}]`.
+- **Proof-carrying refactor**: `verified_change task=<same-task> phase=plan base_ref=<merge-base>` -> edit ->
+  `verified_change task=<same-task> phase=verify base_ref=<same-ref> tests=[{"script":"test","args":[...]}]`.
+  Repeat `task` on both calls; it is required and is not retained between invocations.
   Add `run_tests:true` only when test execution was authorized. `BLOCKED` means an evidenced ratchet
   or test failure; `UNKNOWN` means at least one required proof is incomplete.
 
 - **Orient in the configured repo**: `module_map` → `list_communities` → `god_nodes`. Hub ranking
   is production-only by default; use `include_classified:true` only when tests/generated/build
   surfaces are deliberately part of the question.
-- **Refactor safety for one symbol**: `inspect_symbol` → `get_dependents` → `coverage_map` (low coverage × many
-  dependents ⇒ write tests first) → `read_source`.
+- **Refactor safety for one symbol**: `context_bundle` → optional `inspect_symbol` when raw LSP
+  occurrences, ambiguity details or the larger source window are needed → `get_dependents` →
+  `coverage_map` (low coverage × many dependents ⇒ write tests first) → edit →
+  `verified_change task=<task> phase=verify base_ref=<merge-base>`.
 - **Performance review**: `hot_path_review` → inspect its local evidence with `read_source` → use
   `get_dependents` for change risk → confirm with the repository's profiler/benchmark before editing.
 - **Pre-PR review of your current changes**: `change_impact` (auto merge-base; includes uncommitted
@@ -229,6 +250,10 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
 - **API inventory**: `list_endpoints` (including mount provenance, Next.js App Router, Rust axum and
   actix-web). When one exact route is known, use `trace_endpoint` for its composed mount chain,
   handler and bounded production call graph instead of broad natural-language traversal.
+- **CLI, worker, queue, cron or event flow**: locate the manifest/registration literal with
+  `search_code`, then pin the discovered entry file with `query_graph seed_files=[...]`; use
+  `context_bundle` on its exact handler plus `get_neighbors` / `get_dependents`, and confirm the
+  registration and call sites with `read_source`. Do not force a non-HTTP flow through endpoint tools.
 - **Cross-repository API impact**: ensure both repositories are in `list_known_repos`, then call
   `trace_api_contract backend=<uuid-or-label> clients=[<uuid-or-label>]`; narrow with `method`, `path`,
   or backend `changed_files`. `path` may be a segment-aligned fragment (`/query` can select
@@ -239,8 +264,9 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
   confidence; only an unambiguously resolved handler node can suppress a dead-method candidate.
   `POSSIBLE_EXTERNAL_USE`, `UNKNOWN`, and remaining unresolved/dynamic URLs are incomplete evidence,
   never proof that a method is dead.
-- **Release regression gate**: for a Weavatrix source checkout, use `npm test` for the quick
-  six-language golden corpus and `npm run benchmark` before release for the real MCP
+- **Release regression gate**: for a Weavatrix source checkout, use `npm test` for the full
+  unit/integration suite, `npm run benchmark:quick` for the quick six-language golden corpus, and
+  `npm run benchmark` before release for the golden corpus plus the real MCP
   `full -> incremental -> none -> reconnect/none` lifecycle, bounded output and active-target checks.
   Use `npm run benchmark:real` for available manifest repositories and
   `npm run benchmark:real:release` only when all six source checkouts are present; `MISSING`,
@@ -250,16 +276,25 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
 - **Target architecture before editing**: `get_architecture_contract` → `prepare_change` with the
   intended files → edit and rebuild → `verify_architecture`. A missing contract returns a starter
   proposal from `get_architecture_contract output_format:"json"`, not an automatically approved
-  architecture. Without a contract, `prepare_change` still returns provisional no-regression
-  budgets, but they are guidance rather than enforceable policy. Pull an owner-approved hosted
-  contract only when the user selected `hosted` and explicitly asks for it.
+  architecture. For offline adoption, have the owner review/edit `starterContract`, save it as
+  `.weavatrix/architecture.json`, and rerun the lookup. To establish a ratchet over accepted current
+  debt, run `verify_architecture output_format:"json"`; only after explicit owner approval, copy the
+  accepted `verification.new[*].fingerprint` values into `ratchet.baseline.fingerprints`, save, and
+  verify again so accepted debt is `existing` while later debt is `new`. The v1 verifier classifies
+  ratchet debt by fingerprints; `ratchet.baseline.metrics` is metadata, not a replacement. An approved local exception
+  is applied by adding the exact returned `proposal` to `exceptions`; rerun verification afterward.
+  Without a contract, `prepare_change` still returns provisional no-regression budgets, but they are
+  guidance rather than enforceable policy. Pull an owner-approved hosted contract only when the user
+  selected `hosted` and explicitly asks for it. No Weavatrix tool silently writes either policy.
 - **Behavioral architecture**: `git_history` ranks churn × connectivity hotspots and hidden
   co-change coupling from bounded local numstat history. Always set `top_n`; it is enforced across
   every returned structured collection and JSON reports per-collection truncation. Use it as review
   evidence, not proof that two files must be merged.
 - **Machine output**: keep the default `output_format:"text"` for concise agent conversations; opt
   into `output_format:"json"` only when a workflow consumes the full `weavatrix.tool.v1` envelope.
-- **Find code**: `search_code` (regex + glob) → `get_node` → `read_source`.
+- **Find code**: `search_code` (regex + glob) →
+  `read_source path=<match-path> start_line=<match-line>`; add `get_node` / `get_neighbors` only after
+  identifying an exact graph symbol.
 - **Another repo**: `list_known_repos` → `open_repo <path>`
   (builds or upgrades the graph when needed; `build:false` probes without building).
 
@@ -267,9 +302,29 @@ TypeScript/JavaScript overlay. Java receiver-type call edges are parser-resolved
 
 Weavatrix understands nearest workspace manifests, nested `tsconfig`/`jsconfig` aliases,
 framework-owned runtime peers such as Next.js + `react-dom`, generated NAPI-RS platform loaders,
-and Next.js App Router route exports. For project-specific entry points, reusable template catalogs,
-or Python dependencies supplied by an external runtime, add `.weavatrix-deps.json` at the repository
-root:
+and Next.js App Router route exports. Use repository-root `.weavatrix.json` to correct ambiguous
+production classification without deleting graph evidence:
+
+```json
+{
+  "classify": {
+    "generated": ["src/generated/**"],
+    "test": ["qa/**"],
+    "product": ["benchmarks/core/**"]
+  },
+  "exclude": ["resources/snapshots/**"]
+}
+```
+
+Use `generated` / `test` (or `e2e`, `mock`, `story`, `docs`, `benchmark`, `temp`) for non-production
+code, top-level `exclude` for resource/catalog roots that should stay visible in the graph but not
+drive production-first Health/query ranking, and `product` only to opt a verified benchmark/temp path
+back into production review. `product` does not override an explicit generated/test classification or
+`exclude`. Use `.weavatrixignore` instead only when a path must be removed consistently from graph,
+audit and duplicate scans.
+
+For project-specific entry points, reusable template catalogs, or Python dependencies supplied by an
+external runtime, add `.weavatrix-deps.json` at the repository root:
 
 ```json
 {

package/src/analysis/allowed-test-runner.js

@@ -19,29 +19,40 @@ function packageManager(repoRoot) {
   return 'npm'
 }
 
-export function validateTestRequests(repoRoot, requests = []) {
-  const manifest = manifestAt(repoRoot)
-  if (!manifest) return {ok: false, reason: 'package.json is missing or unreadable', tests: []}
+function normalizeTestRequests(requests = []) {
   const tests = []
-  for (const request of requests.slice(0, 5)) {
+  for (const request of (Array.isArray(requests) ? requests : []).slice(0, 5)) {
     const script = String(request?.script || '')
     const args = Array.isArray(request?.args) ? request.args.slice(0, 40).map(String) : []
     if (!SAFE_SCRIPT.test(script)) return {ok: false, reason: `script ${script || '(missing)'} is outside the test/check/verify allowlist`, tests}
-    if (!Object.hasOwn(manifest.scripts || {}, script)) return {ok: false, reason: `package.json has no script named ${script}`, tests}
     if (args.some((arg) => arg.length > 300 || UNSAFE_SHELL_ARG.test(arg))) return {ok: false, reason: `script ${script} has an invalid or shell-sensitive argument`, tests}
     tests.push({script, args})
   }
+  return {ok: true, tests}
+}
+
+export function validateTestRequests(repoRoot, requests = []) {
+  const normalized = normalizeTestRequests(requests)
+  if (!normalized.ok || !normalized.tests.length) return normalized
+  const manifest = manifestAt(repoRoot)
+  if (!manifest) return {ok: false, reason: 'package.json is missing or unreadable', tests: []}
+  for (const test of normalized.tests) {
+    if (!Object.hasOwn(manifest.scripts || {}, test.script)) return {ok: false, reason: `package.json has no script named ${test.script}`, tests: []}
+  }
+  const tests = normalized.tests
   return {ok: true, tests, packageManager: packageManager(repoRoot)}
 }
 
 export async function runAllowedTests(repoRoot, requests = [], {enabled = false, timeoutMs = 60_000} = {}) {
-  const checked = validateTestRequests(repoRoot, requests)
-  if (!checked.ok) return {state: 'BLOCKED', reason: checked.reason, results: []}
-  if (!checked.tests.length) return {state: 'NOT_REQUESTED', reason: 'no package scripts were requested', results: []}
+  const normalized = normalizeTestRequests(requests)
+  if (!normalized.ok) return {state: 'BLOCKED', reason: normalized.reason, results: []}
+  if (!normalized.tests.length) return {state: 'NOT_REQUESTED', reason: 'no package scripts were requested', plan: [], results: []}
   if (!enabled || process.env.WEAVATRIX_ALLOW_TEST_RUNS !== '1') return {
     state: 'DISABLED', reason: 'set WEAVATRIX_ALLOW_TEST_RUNS=1 and pass run_tests:true to execute allowlisted package scripts',
-    plan: checked.tests, results: [],
+    plan: normalized.tests, results: [],
   }
+  const checked = validateTestRequests(repoRoot, normalized.tests)
+  if (!checked.ok) return {state: 'BLOCKED', reason: checked.reason, results: []}
   const results = []
   const timeout = Math.max(1000, Math.min(300_000, Number(timeoutMs) || 60_000))
   for (const test of checked.tests) {

package/src/mcp/catalog.mjs

@@ -169,6 +169,7 @@ export async function loadHotApi(version, capsArg) {
         import(new URL(`./tools-verified-change.mjs${v}`, import.meta.url).href),
     ])
     const raw = capsArg == null ? 'offline' : String(capsArg).trim()
+    const profile = Object.hasOwn(PROFILE_CAPS, raw) ? raw : 'custom'
     const selected = PROFILE_CAPS[raw] || raw.split(',').map((s) => s.trim()).filter(Boolean)
         .flatMap((cap) => cap === 'online' ? ['advisories', 'hosted'] : [cap])
     const caps = new Set(selected)
@@ -178,6 +179,7 @@ export async function loadHotApi(version, capsArg) {
         tools,
         byName: new Map(tools.map((t) => [t.name, t])),
         caps,
+        profile,
         stalenessLine,
         resetStalenessCache,
     }

package/src/mcp/tools-graph.mjs

@@ -40,6 +40,7 @@ export function tGraphStats(g, ctx) {
     const precision = g.precision || {state: 'UNAVAILABLE', verifiedEdges: 0, candidates: 0, queried: 0, reason: 'no revision-matched precision overlay'}
     return [
         `Graph summary`,
+        ctx?.runtime ? `- Weavatrix runtime: v${ctx.runtime.version}; profile ${ctx.runtime.profile}; ${ctx.runtime.toolCount} registered tools; capabilities: ${ctx.runtime.capabilities.join(',') || '(none)'}` : null,
         ctx?.repoRoot ? `- Repo: ${ctx.repoRoot}` : null,
         ctx?.graphPath ? `- Graph: ${ctx.graphPath}` : null,
         `- Build mode: ${g.graphBuildMode || 'full'}`,

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

@@ -126,10 +126,18 @@ export async function tVerifiedChange(g, args = {}, ctx = {}, tools = {}, permis
     })
     : {model: 'bounded call-argument-to-parameter evidence (not CFG or taint analysis)', status: 'UNAVAILABLE', reason: 'source capability is not enabled', edges: [], unsupportedEdges: 0, capped: false}
   const suggestedTests = targetTests(impact)
-  const checkedTests = validateTestRequests(ctx.repoRoot, args.tests || [])
-  const testProof = phase === 'verify'
-    ? await runAllowedTests(ctx.repoRoot, args.tests || [], {enabled: args.run_tests === true, timeoutMs: args.test_timeout_ms})
-    : {state: checkedTests.ok ? 'PLANNED' : 'BLOCKED', reason: checkedTests.reason, plan: checkedTests.tests || [], results: []}
+  const requestedTests = Array.isArray(args.tests) ? args.tests : []
+  let testProof
+  if (!requestedTests.length) {
+    testProof = {state: 'NOT_REQUESTED', reason: 'no package scripts were requested', plan: [], results: []}
+  } else if (args.run_tests !== true) {
+    testProof = await runAllowedTests(ctx.repoRoot, requestedTests, {enabled: false, timeoutMs: args.test_timeout_ms})
+  } else if (phase === 'verify') {
+    testProof = await runAllowedTests(ctx.repoRoot, requestedTests, {enabled: true, timeoutMs: args.test_timeout_ms})
+  } else {
+    const checkedTests = validateTestRequests(ctx.repoRoot, requestedTests)
+    testProof = {state: checkedTests.ok ? 'PLANNED' : 'BLOCKED', reason: checkedTests.reason, plan: checkedTests.tests || [], results: []}
+  }
   const testCoverageState = testCoverage(testProof, args.tests || [], suggestedTests)
 
   const architectureValue = phase === 'verify'

package/src/mcp-server.mjs

@@ -85,11 +85,21 @@ function hotVersion(hotFiles) {
 async function main() {
     let catalog = await loadCatalog()
     let api = await catalog.loadHotApi(0, CAPS_ARG)
+    const runtimeInfo = () => ({
+        version: PKG_VERSION,
+        profile: api.profile || 'custom',
+        capabilities: [...api.caps],
+        toolCount: api.tools.length,
+    })
+    const runtimeInstructions = () => {
+        const runtime = runtimeInfo()
+        return `Weavatrix ${runtime.version}; profile=${runtime.profile}; tools=${runtime.toolCount}; capabilities=${runtime.capabilities.join(',') || '(none)'}. If this differs from the client-visible tool list, reconnect the MCP client to discard its cached schema.`
+    }
     let graph = null
     let graphError = null
     // ctx owns the CURRENT target: rebuild_graph reloads it, open_repo retargets graphPath/repoRoot
     // at runtime. loadInto always reads ctx.graphPath so both paths share one loader.
-    const ctx = {graphPath: GRAPH_PATH, repoRoot: REPO_ROOT, reload: null}
+    const ctx = {graphPath: GRAPH_PATH, repoRoot: REPO_ROOT, reload: null, runtime: runtimeInfo()}
     const loadInto = () => { graph = loadGraph(ctx.graphPath, {repoRoot: ctx.repoRoot}); graphError = null; return graph }
     ctx.reload = () => { api.resetStalenessCache(); try { return loadInto() } catch (e) { graphError = e.message; return null } }
     try {
@@ -229,6 +239,7 @@ async function main() {
             const nextApi = await nextCatalog.loadHotApi(v, CAPS_ARG)
             catalog = nextCatalog
             api = nextApi
+            ctx.runtime = runtimeInfo()
             loadedVersion = v
             log(`hot-reloaded tool implementations from changed source (${api.tools.length} tools)`)
             send({jsonrpc: '2.0', method: 'notifications/tools/list_changed'})
@@ -247,14 +258,17 @@ async function main() {
         }
         if (method === 'initialize') {
             if (params?.protocolVersion) protocolVersion = String(params.protocolVersion)
-            return reply(id, {protocolVersion, capabilities: {tools: {listChanged: true}}, serverInfo: SERVER_INFO})
+            return reply(id, {protocolVersion, capabilities: {tools: {listChanged: true}}, serverInfo: SERVER_INFO, instructions: runtimeInstructions()})
         }
         if (method === 'notifications/initialized' || method === 'initialized') return
         if (method === 'ping') return reply(id, {})
         if (method === 'tools/list') {
             await maybeHotReload()
             if (shuttingDown) return
-            return reply(id, {tools: api.tools.map(({name, description, inputSchema, outputSchema}) => ({name, description, inputSchema, outputSchema}))})
+            return reply(id, {
+                tools: api.tools.map(({name, description, inputSchema, outputSchema}) => ({name, description, inputSchema, outputSchema})),
+                _meta: {'weavatrix/runtime': runtimeInfo()},
+            })
         }
         if (method === 'tools/call') {
             await maybeHotReload()

package/docs/releases/v0.2.11.md

@@ -1,23 +0,0 @@
-# Weavatrix 0.2.11
-
-## MCP Registry publication hotfix
-
-0.2.11 is the immutable follow-up to 0.2.10. The 0.2.10 npm package published successfully, but
-the official MCP Registry rejected its expanded server description because that field exceeded the
-Registry's 100-character limit. This patch shortens only the Registry summary while preserving the
-broad product positioning across the package, MCPB, skill, README and public site. The release
-verifier now enforces the same 1-100 character boundary before a tag can publish.
-
-The runtime is otherwise the verified 0.2.10 release: 38 graph-backed methods for fast application
-understanding, Health, dependencies, dead-code and duplicate review, history, endpoint and impact
-tracing, proof-carrying changes, target-architecture ratchets and explicit Hosted governance. Its
-Java receiver-aware call resolver and product-code-only architecture starter are unchanged.
-
-## Compatibility and verification
-
-- Tool names, input schemas, result envelopes and Hosted sync payload v2/v3 remain unchanged.
-- Full Node suite: 506 tests, 503 passed, 3 platform skips, 0 failed.
-- Six-language, cross-repository, framework and MCP lifecycle benchmark: `PASS`.
-- Six available real-repository baselines: 6/6 `PASS`.
-- Repo Lens portable analyzer parity: 21/21 methods present in the default offline profile.
-- Release metadata, MCP Registry description length and MCPB manifest validation: `PASS`.