weavatrix 0.2.12 → 0.2.13

package/README.md

@@ -194,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
@@ -342,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.12",
+  "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.12.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;
@@ -63,15 +70,17 @@ projection; expand only when the answer requires it.
   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`; it distinguishes additive
-  exports from signature/body/removal risk and separates runtime/type-only radius plus available
-  measured coverage or explicitly static reachability.
+- **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,
+- **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.
 
@@ -101,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
@@ -195,17 +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` → `context_bundle` → `get_dependents` →
+- **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 phase=verify base_ref=<merge-base>`.
+  `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
@@ -238,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
@@ -248,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`,
@@ -259,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).
 
@@ -276,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.12.md

@@ -1,45 +0,0 @@
-# Weavatrix 0.2.12
-
-## Agent workflow routing and cross-repository API clarity
-
-0.2.12 incorporates a second hands-on evaluation across Weavatrix, BranchPilot,
-controller-rest-api and its registered clients. It does not reduce the product to a short list: the
-skill still maps all 38 methods across application understanding, graph views, Health, dependencies,
-dead code, duplicates, coverage, history, endpoints, impact, architecture and Hosted governance.
-
-The skill now makes three high-leverage routing decisions explicit:
-
-- prefer `trace_api_contract` over disconnected per-repository searches when a backend change can
-  affect registered clients;
-- use `change_impact` as a diff-risk classifier that separates additive exports from
-  signature/body/removal risk, runtime/type-only radius and honest coverage evidence;
-- treat `verified_change` as a proof layer around an agent's edit, never a hidden source editor or
-  auto-fix.
-
-The one-symbol refactor workflow now carries exact context, dependents and coverage through the
-post-edit `verified_change` ratchet. The public site also surfaces cross-repository API contract
-tracing as a first-class graph capability rather than hiding it under generic multi-repository mode.
-
-## Worked examples and public benchmark evidence
-
-The README and public site now show four concrete dogfood scenarios instead of relying on feature
-names alone: orienting inside a 1,076-file backend and tracing one of 462 observed routes; proving
-external handler use across three registered repositories; classifying a BranchPilot change before
-editing; and turning Health plus clone evidence into a bounded review queue. The examples preserve
-uncertainty for dynamic URLs, advisory coverage and review-required findings.
-
-The public benchmark section reports reproducible fixture and revision-pinned real-repository
-regression gates with dates, environment, commands and explicit limits. It does not present these
-machine-dependent local measurements as competitor benchmarks. A lightweight CSS motion sequence
-illustrates the graph-to-verdict workflow and respects `prefers-reduced-motion`; no synthetic product
-screenshots are used.
-
-## Compatibility and verification
-
-- Runtime implementation, tool names, schemas and result envelopes are unchanged from 0.2.11.
-- Hosted sync payload v2/v3 and architecture-contract transport are unchanged.
-- Skill inventory: all 38 current methods are routed; 0 missing.
-- Full Node suite baseline: 506 tests, 503 passed, 3 platform skips, 0 failed.
-- Six-language fixture, cross-repository and lifecycle benchmark: `PASS`.
-- Six locally available revision-pinned real-repository baselines: `PASS`.
-- Release metadata, 99-character MCP Registry description and MCPB validation: `PASS`.