weavatrix 0.3.12 → 0.3.14

package/src/mcp/company-contract-page.mjs

@@ -0,0 +1,142 @@
+import {createHash} from 'node:crypto'
+
+const DEFAULT_PAGE_SIZE = 10
+const MAX_PAGE_SIZE = 50
+const DEFAULT_RELATED_LIMIT = 5
+const MAX_RELATED_LIMIT = 25
+
+export class ContractCursorError extends Error {
+    constructor(message) {
+        super(message)
+        this.name = 'ContractCursorError'
+        this.code = 'INVALID_CURSOR'
+    }
+}
+
+const boundedInteger = (value, fallback, minimum, maximum) => {
+    const parsed = Number(value)
+    return Number.isInteger(parsed) ? Math.max(minimum, Math.min(maximum, parsed)) : fallback
+}
+
+const pageFingerprint = (parts) => createHash('sha256')
+    .update(JSON.stringify(parts))
+    .digest('hex')
+    .slice(0, 24)
+
+const encodeCursor = (fingerprint, offset) => Buffer
+    .from(JSON.stringify({v: 1, fingerprint, offset}), 'utf8')
+    .toString('base64url')
+
+function decodeCursor(raw, fingerprint, total) {
+    if (!raw) return 0
+    try {
+        const parsed = JSON.parse(Buffer.from(String(raw), 'base64url').toString('utf8'))
+        if (parsed?.v !== 1 || parsed.fingerprint !== fingerprint) {
+            throw new ContractCursorError('cursor does not belong to this repository revision and filter set')
+        }
+        if (!Number.isInteger(parsed.offset) || parsed.offset < 0 || parsed.offset > total) {
+            throw new ContractCursorError('cursor offset is outside the available evidence')
+        }
+        return parsed.offset
+    } catch (error) {
+        if (error instanceof ContractCursorError) throw error
+        throw new ContractCursorError('cursor is malformed')
+    }
+}
+
+const sample = (items, limit) => ({
+    total: Array.isArray(items) ? items.length : 0,
+    items: Array.isArray(items) ? items.slice(0, limit) : [],
+    truncated: Array.isArray(items) && items.length > limit,
+})
+
+function compactEndpoint(endpoint, relatedLimit) {
+    const affected = endpoint?.affected || {}
+    return {
+        kind: 'http-endpoint',
+        backend: endpoint.backend,
+        method: endpoint.method,
+        path: endpoint.path,
+        normalizedPath: endpoint.normalizedPath,
+        handler: endpoint.handler,
+        handlerNodeId: endpoint.handlerNodeId,
+        handlerResolution: endpoint.handlerResolution,
+        file: endpoint.file,
+        line: endpoint.line,
+        callsites: sample(endpoint.callsites, relatedLimit),
+        methodMismatches: endpoint.methodMismatches,
+        methodMismatchSites: sample(endpoint.methodMismatchSites, relatedLimit),
+        liveness: endpoint.liveness,
+        affected: {
+            complete: affected.complete === true,
+            files: sample(affected.files, relatedLimit),
+            screens: sample(affected.screens, relatedLimit),
+            modules: sample(affected.modules, relatedLimit),
+            traversalTruncated: affected.truncated || {},
+        },
+    }
+}
+
+function compactTransport(contract, relatedLimit) {
+    const affected = contract?.affected || {}
+    return {
+        kind: 'transport-contract',
+        transport: contract.transport,
+        side: contract.side,
+        service: contract.service,
+        operation: contract.operation,
+        name: contract.name,
+        file: contract.file,
+        line: contract.line,
+        detector: contract.detector,
+        liveness: contract.liveness,
+        runtimeObserved: contract.runtimeObserved === true,
+        callsites: sample(contract.callsites, relatedLimit),
+        affected: {
+            complete: affected.complete === true,
+            files: sample(affected.files, relatedLimit),
+            screens: sample(affected.screens, relatedLimit),
+            modules: sample(affected.modules, relatedLimit),
+            traversalTruncated: affected.truncated || {},
+        },
+    }
+}
+
+function evidenceItems(analysis, transportAnalysis) {
+    return [
+        ...(analysis.endpoints || []).map((value) => ({kind: 'http-endpoint', value})),
+        ...(transportAnalysis.contracts || []).map((value) => ({kind: 'transport-contract', value})),
+        ...(analysis.uncertain || []).map((value) => ({kind: 'http-uncertain', value})),
+        ...(transportAnalysis.uncertain || []).map((value) => ({kind: 'transport-uncertain', value})),
+    ]
+}
+
+function projectItem(item, detail, relatedLimit) {
+    if (detail === 'full') return {kind: item.kind, ...item.value}
+    if (item.kind === 'http-endpoint') return compactEndpoint(item.value, relatedLimit)
+    if (item.kind === 'transport-contract') return compactTransport(item.value, relatedLimit)
+    return {kind: item.kind, ...item.value}
+}
+
+export function paginateContractEvidence({analysis, transportAnalysis, args = {}, fingerprintParts = []}) {
+    const detail = args.response_detail === 'full' ? 'full' : 'compact'
+    const pageSize = boundedInteger(args.page_size, DEFAULT_PAGE_SIZE, 1, MAX_PAGE_SIZE)
+    const relatedLimit = boundedInteger(args.per_item_limit, DEFAULT_RELATED_LIMIT, 1, MAX_RELATED_LIMIT)
+    const all = evidenceItems(analysis, transportAnalysis)
+    const fingerprint = pageFingerprint(fingerprintParts)
+    const offset = decodeCursor(args.cursor, fingerprint, all.length)
+    const selected = all.slice(offset, offset + pageSize)
+    const nextOffset = offset + selected.length
+    const nextCursor = nextOffset < all.length ? encodeCursor(fingerprint, nextOffset) : null
+    return {
+        detail,
+        offset,
+        pageSize,
+        perItemLimit: detail === 'compact' ? relatedLimit : null,
+        totalItems: all.length,
+        returnedItems: selected.length,
+        hasMore: nextCursor !== null,
+        nextCursor,
+        items: selected.map((item) => projectItem(item, detail, relatedLimit)),
+    }
+}

package/src/mcp/company-contract-reconcile.mjs

@@ -0,0 +1,87 @@
+import {join} from 'node:path'
+import {buildGraphForRepo} from '../build-graph.js'
+import {persistedFreshnessMatches, repositoryFreshnessProbe} from '../graph/freshness-probe.js'
+import {loadGraph} from './graph-context.mjs'
+
+export const publicRecord = (record, alias) => ({repositoryId: record.repositoryId, label: record.label, alias})
+
+function safeRefreshReason(record, error) {
+    let message = String(error instanceof Error ? error.message : error || 'graph refresh failed')
+    for (const path of [record.repoPath, record.graphDir]) {
+        if (!path) continue
+        message = message.split(String(path)).join(record.label || 'repository')
+        message = message.split(String(path).replace(/\\/g, '/')).join(record.label || 'repository')
+    }
+    return message.replace(/[\r\n]+/g, ' ').trim().slice(0, 400) || 'graph refresh failed'
+}
+
+export async function reconcileGraph(record, alias, role, graphHome) {
+    let registeredGraph = null
+    try { registeredGraph = loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}) } catch { /* refresh may repair it */ }
+    const buildMode = ['full', 'no-tests', 'tests-only'].includes(registeredGraph?.graphBuildMode)
+        ? registeredGraph.graphBuildMode
+        : 'full'
+    const precision = registeredGraph?.graphPrecisionMode === 'off' ? 'off' : 'lsp'
+    const freshnessProbe = repositoryFreshnessProbe(record.repoPath)
+    if (registeredGraph && freshnessProbe && persistedFreshnessMatches(registeredGraph, freshnessProbe, buildMode)) {
+        return {
+            record,
+            alias,
+            graph: registeredGraph,
+            publicStatus: {
+                role,
+                repository: publicRecord(record, alias),
+                buildMode,
+                status: 'CURRENT',
+                refresh: {kind: 'none', reason: 'persisted-freshness-match', changedFileCount: 0},
+            },
+        }
+    }
+    let build
+    try {
+        build = await buildGraphForRepo(record.repoPath, {
+            mode: buildMode,
+            precision,
+            scope: '',
+            outDir: record.graphDir,
+            graphHome,
+        })
+    } catch (error) {
+        build = {ok: false, error: safeRefreshReason(record, error)}
+    }
+    const refreshKind = build?.refresh?.kind || null
+    const changedFiles = Array.isArray(build?.refresh?.changedFiles) ? build.refresh.changedFiles : []
+    const publicStatus = {
+        role,
+        repository: publicRecord(record, alias),
+        buildMode,
+        status: build?.ok ? (refreshKind === 'none' ? 'CURRENT' : 'REFRESHED') : 'STALE_FALLBACK',
+        refresh: build?.ok ? {
+            kind: refreshKind || 'full',
+            reason: String(build?.refresh?.reason || 'graph-rebuilt'),
+            changedFileCount: changedFiles.length,
+        } : null,
+    }
+    if (build?.ok) {
+        try {
+            return {record, alias, graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}), publicStatus}
+        } catch (error) {
+            const reason = `refreshed graph could not be loaded: ${safeRefreshReason(record, error)}`
+            return {record, alias, graph: null, reason, publicStatus: {...publicStatus, status: 'FAILED', reason}}
+        }
+    }
+
+    const reason = `graph refresh failed: ${safeRefreshReason(record, build?.error)}`
+    try {
+        return {
+            record,
+            alias,
+            graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}),
+            reason: `${reason}; stale registered graph used`,
+            publicStatus: {...publicStatus, reason: `${reason}; stale registered graph used`},
+        }
+    } catch (error) {
+        const loadReason = `${reason}; registered graph could not be loaded: ${safeRefreshReason(record, error)}`
+        return {record, alias, graph: null, reason: loadReason, publicStatus: {...publicStatus, status: 'FAILED', reason: loadReason}}
+    }
+}

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

@@ -8,7 +8,7 @@ import {compareDuplicateMember} from './evidence/duplicate-member-order.mjs'
 const CLONE_MIN_SIMILARITY = 80
 const DIVERGENCE_MAX_SIMILARITY = 45
 const MIN_TOKENS = 50
-const FILTERED_CLASSES = new Set(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const FILTERED_CLASSES = new Set(['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const SAFE_SYMBOL = /^[A-Za-z_$][A-Za-z0-9_$]*$/
 
 const DUPLICATE_EVIDENCE_THRESHOLDS = Object.freeze({

package/src/mcp/graph/context-seeds.mjs

@@ -205,10 +205,3 @@ export function resolveSeedFiles(g, requested, limit = 12) {
     }
     return {seeds, missing}
 }
-
-export function undirectedNeighbors(g, id) {
-    const seen = new Map()
-    for (const e of g.out.get(id) || []) if (e.barrelProxy !== true) seen.set(e.id, e.relation)
-    for (const e of g.inn.get(id) || []) if (e.barrelProxy !== true && !seen.has(e.id)) seen.set(e.id, e.relation)
-    return seen
-}

package/src/mcp/graph/tools-query.mjs

@@ -1,10 +1,10 @@
 import {
     isSymbol, degreeOf, labelOf, resolveNode, findSeeds, resolveSeedFiles,
-    undirectedNeighbors, requestedPathClasses,
+    requestedPathClasses,
 } from '../graph-context.mjs'
 import {createPathClassifier, hasPathClass} from '../../path-classification.js'
 
-const QUERY_NON_PRODUCT = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const QUERY_NON_PRODUCT = Object.freeze(['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const LOW_SIGNAL_SYMBOL_RE = /^(?:const(?:ant)?|variable|property|field|enum_member)$/i
 const AMBIGUOUS_FILE_BASENAME_RE = /^(mod|lib|main)\.rs$|^index\.[a-z0-9]+$|^__init__\.py$/
 const querySourceFile = (node) => String(node?.source_file || String(node?.id || '').split('#', 1)[0]).replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
@@ -52,6 +52,22 @@ const makeEdgeLabel = (g, shownIds) => {
     }
 }
 
+// shortest_path is intentionally a connectivity query, so it may walk an edge in either
+// direction. Keep the stored direction on every hop so the rendered path never turns a reverse
+// traversal into a false caller/importer direction.
+const connectivityNeighbors = (g, id) => {
+    const seen = new Map()
+    for (const edge of g.out.get(id) || []) {
+        if (edge.barrelProxy !== true) seen.set(String(edge.id), {relation: edge.relation, direction: 'forward'})
+    }
+    for (const edge of g.inn.get(id) || []) {
+        if (edge.barrelProxy !== true && !seen.has(String(edge.id))) {
+            seen.set(String(edge.id), {relation: edge.relation, direction: 'backward'})
+        }
+    }
+    return seen
+}
+
 const relationSet = (relationFilter, legacyFilter) => {
     const raw = relationFilter ?? legacyFilter
     const values = Array.isArray(raw) ? raw : (raw == null ? [] : String(raw).split(','))
@@ -221,17 +237,17 @@ export function tShortestPath(g, {source, target, max_hops = 8} = {}) {
     if (sourceId === targetId) return `Source and target are the same node: ${sourceNode.label ?? sourceId}.`
     const limit = Math.max(1, Math.min(20, Number(max_hops) || 8))
     const previous = new Map([[sourceId, null]])
-    const relationTo = new Map()
+    const edgeTo = new Map()
     let frontier = [sourceId]
     let hops = 0
     let found = false
     while (frontier.length && hops < limit && !found) {
         const next = []
         for (const id of frontier) {
-            for (const [neighbor, relation] of undirectedNeighbors(g, id)) {
+            for (const [neighbor, edge] of connectivityNeighbors(g, id)) {
                 if (previous.has(neighbor)) continue
                 previous.set(neighbor, id)
-                relationTo.set(neighbor, relation)
+                edgeTo.set(neighbor, edge)
                 if (neighbor === targetId) { found = true; break }
                 next.push(neighbor)
             }
@@ -244,6 +260,17 @@ export function tShortestPath(g, {source, target, max_hops = 8} = {}) {
     const path = []
     for (let current = targetId; current != null; current = previous.get(current)) path.unshift(current)
     const edgeLabel = makeEdgeLabel(g, path)
-    const lines = path.map((id, index) => index === 0 ? `  ${edgeLabel(id)}` : `  --${relationTo.get(id) || 'rel'}--> ${edgeLabel(id)}`)
-    return [`Shortest path (${path.length - 1} hops): ${sourceNode.label ?? sourceId} → ${targetNode.label ?? targetId}`, ...lines].join('\n')
+    const hopCount = path.length - 1
+    const lines = path.map((id, index) => {
+        if (index === 0) return `  ${edgeLabel(id)}`
+        const edge = edgeTo.get(id) || {}
+        return edge.direction === 'backward'
+            ? `  <--${edge.relation || 'rel'}-- ${edgeLabel(id)}`
+            : `  --${edge.relation || 'rel'}--> ${edgeLabel(id)}`
+    })
+    return [
+        `Shortest path (${hopCount} ${hopCount === 1 ? 'hop' : 'hops'}; undirected connectivity) from ${edgeLabel(sourceId)} to ${edgeLabel(targetId)}`,
+        'Edge arrows preserve stored graph direction; traversal may move with or against them.',
+        ...lines,
+    ].join('\n')
 }

package/src/mcp/health/audit-format.mjs

@@ -3,7 +3,7 @@ import {runGit} from '../../git-exec.js'
 import {createPathClassifier, hasPathClass} from '../../path-classification.js'
 
 const SEVERITY_RANK = {critical: 0, high: 1, medium: 2, low: 3, info: 4}
-const AUDIT_NON_PRODUCT_CLASSES = ['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
+const AUDIT_NON_PRODUCT_CLASSES = ['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp']
 
 export function formatAuditFinding(f) {
     const where = f.file ? `  (${f.file}${f.symbol ? ` ${f.symbol}` : ''})` : f.package ? `  (pkg ${f.package}${f.version ? `@${f.version}` : ''}${f.manifest ? `; ${f.manifest}` : ''})` : ''
@@ -168,7 +168,7 @@ export const formatOrdinaryAudit = (audit, args, findings = audit.findings, head
         ...auditCapabilityLines(audit),
         ...auditExtensionLines(audit),
         `Scoped severity: critical ${sev.critical}, high ${sev.high}, medium ${sev.medium}, low ${sev.low}, info ${sev.info}. Scoped categories: unused ${bycat.unused}, structure ${bycat.structure}, vulnerability ${bycat.vulnerability}, malware ${bycat.malware}.`,
-        pathScope.suppressed ? `Path policy: production-first; suppressed ${pathScope.suppressed} finding(s) whose evidence is entirely test/e2e/generated/mock/story/docs/benchmark/temp or explicitly excluded. Pass include_classified:true to include them.` : 'Path policy: production-first; no classified-only findings were suppressed.',
+        pathScope.suppressed ? `Path policy: production-first; suppressed ${pathScope.suppressed} finding(s) whose evidence is entirely test/e2e/generated/vendored/mock/story/docs/benchmark/temp or explicitly excluded. Pass include_classified:true to include them.` : 'Path policy: production-first; no classified-only findings were suppressed.',
         `Repository-level ${auditChecksLine(audit)}`,
         '',
         `Showing ${shown.length} of ${filtered.length} finding(s)${args.category ? ` in category "${args.category}"` : ''}${args.min_severity ? ` at ≥${args.min_severity}` : ''}:`,

package/src/mcp/health/audit.mjs

@@ -11,6 +11,7 @@ import {buildInternalGraph} from '../../graph/internal-builder.js'
 import {resolveGitCommit, withGitRefCheckout} from '../../analysis/git-ref-graph.js'
 import {filterGraphForMode} from '../../graph/graph-filter.js'
 import {toolResult} from '../tool-result.mjs'
+import {summarizeFindings} from '../../analysis/findings.js'
 const auditFormatVersion = new URL(import.meta.url).search
 const {
   auditFilter,
@@ -147,16 +148,22 @@ async function runAuditWithBaseline(args, ctx, currentGraph) {
 // unused deps), structure (import cycles / orphans / boundary rules), supply-chain (offline OSV
 // advisories, typosquat, lockfile drift), optional malware heuristics.
 export async function tRunAudit(g, args, ctx) {
-    if (!ctx.repoRoot) return 'Audit needs the repo root (not provided to this server).'
+    if (!ctx.repoRoot) return toolResult('Audit needs the repo root (not provided to this server).', {
+        status: 'INVALID', findings: [], reason: 'repo root unavailable',
+    }, {completeness: {status: 'PARTIAL', reason: 'repo root unavailable'}})
     if (args.base_ref) return runAuditWithBaseline(args, ctx, rawGraph(ctx))
     const graph = effectiveRawGraph(ctx)
     const audit = await runAudit(ctx.repoRoot, graph, args, ctx, {
         skipMalwareScan: !args.include_malware_scan, // greps installed packages — slow, so opt-in
     })
-    if (!audit.ok) return `Audit failed: ${audit.error}`
+    if (!audit.ok) return toolResult(`Audit failed: ${audit.error}`, {
+        status: 'ERROR', findings: [], reason: audit.error,
+    }, {completeness: {status: 'PARTIAL', reason: audit.error}})
     if (Array.isArray(args.changed_files)) {
         const normalized = normalizeAuditScopeFiles(args.changed_files)
-        if (!normalized.ok) return `Changed-scope audit invalid: ${normalized.error}.`
+        if (!normalized.ok) return toolResult(`Changed-scope audit invalid: ${normalized.error}.`, {
+            status: 'INVALID', mode: 'changed-scope', findings: [], reason: normalized.error,
+        }, {completeness: {status: 'PARTIAL', reason: normalized.error}})
         const scoped = scopeAuditFindings(audit.findings, normalized.files)
         const text = formatOrdinaryAudit(audit, args, scoped,
             `CHANGED-SCOPE ONLY — ${normalized.files.length} explicitly supplied file(s); no baseline was provided, so these findings are not classified as new, existing, or fixed.`, ctx.repoRoot)
@@ -168,7 +175,25 @@ export async function tRunAudit(g, args, ctx) {
             findings: auditFilter(audit, args, scoped, ctx.repoRoot),
         }, {completeness: {status: 'COMPLETE'}})
     }
-    return formatOrdinaryAudit(audit, args, audit.findings, null, ctx.repoRoot)
+    const filtered = auditFilter(audit, args, audit.findings, ctx.repoRoot)
+    const max = Math.max(1, Math.min(100, Number(args.max_findings) || 30))
+    const shown = filtered.slice(0, max)
+    return toolResult(formatOrdinaryAudit(audit, args, audit.findings, null, ctx.repoRoot), {
+        status: 'COMPLETE',
+        mode: 'ordinary',
+        repo: audit.repo,
+        scanned: audit.scanned,
+        summary: summarizeFindings(filtered),
+        findings: shown,
+        healthCapabilities: audit.healthCapabilities,
+        extensionCapabilities: audit.extensionCapabilities || [],
+        dependencyReport: audit.dependencyReport,
+        conventionReachability: audit.conventionReachability,
+        checks: audit.checks,
+    }, {
+        page: {shown: shown.length, total: filtered.length, capped: shown.length < filtered.length},
+        completeness: {status: 'COMPLETE'},
+    })
 }
 
 // Named module clusters: graph communities labeled by their dominant folder instead of bare numbers.

package/src/mcp/health/duplicates.mjs

@@ -1,7 +1,8 @@
 import {computeDuplicates} from '../../analysis/duplicates.js'
 import {analyzeDuplicateGroups} from '../../analysis/duplicate-groups.js'
+import {toolResult} from '../tool-result.mjs'
 
-const NON_PRODUCT_DUPLICATE_CLASSES = new Set(['generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const NON_PRODUCT_DUPLICATE_CLASSES = new Set(['generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const fragmentEligible = (fragment, {tokMin, skipTests, includeClassified}) => {
     if (fragment.n < tokMin) return false
     const classes = new Set(fragment.classes || [])
@@ -11,7 +12,9 @@ const fragmentEligible = (fragment, {tokMin, skipTests, includeClassified}) => {
 }
 
 export function tFindDuplicates(g, args, ctx) {
-    if (!ctx.repoRoot) return 'Duplicate scan needs the repo root (not provided to this server).'
+    if (!ctx.repoRoot) return toolResult('Duplicate scan needs the repo root (not provided to this server).', {
+        status: 'INVALID', groups: [], reason: 'repo root unavailable',
+    }, {completeness: {status: 'PARTIAL', reason: 'repo root unavailable'}})
     const simMin = Math.min(100, Math.max(50, Number(args.min_similarity) || 80))
     const tokMin = Math.min(400, Math.max(12, Number(args.min_tokens) || 50))
     const mode = args.mode === 'strict' ? 'strict' : 'renamed'
@@ -40,7 +43,11 @@ export function tFindDuplicates(g, args, ctx) {
                 ? b.pair.similarity - a.pair.similarity || b.tokens - a.tokens
                 : b.tokens - a.tokens || a.pair.similarity - b.pair.similarity
         })
-        if (!candidates.length) return 'No actionable same-name pairs across files (semantic mode; ambiguous middle-similarity pairs are suppressed).'
+        if (!candidates.length) return toolResult(
+            'No actionable same-name pairs across files (semantic mode; ambiguous middle-similarity pairs are suppressed).',
+            {status: 'COMPLETE', mode: 'semantic', total: 0, groups: [], thresholds: {minTokens: tokMin}},
+            {page: {shown: 0, total: 0, capped: false}, completeness: {status: 'COMPLETE'}},
+        )
         const top = candidates.slice(0, Math.min(30, Math.max(1, Number(args.top_n) || 15)))
         const lines = top.map((item, k) => {
             const a = frags[item.pair.a]
@@ -54,14 +61,23 @@ export function tFindDuplicates(g, args, ctx) {
                 `     ${b.file}:${b.start}-${b.end}  (${b.n} tok)`,
             ].join('\n')
         })
-        return `Found ${candidates.length} actionable same-name pair(s) across files (semantic mode; one closest clone and/or farthest collision per name). Top ${top.length}:\n\n${lines.join('\n\n')}\n\nThese are review candidates, not automatic refactors. Use read_source on both sites before changing code.`
+        const text = `Found ${candidates.length} actionable same-name pair(s) across files (semantic mode; one closest clone and/or farthest collision per name). Top ${top.length}:\n\n${lines.join('\n\n')}\n\nThese are review candidates, not automatic refactors. Use read_source on both sites before changing code.`
+        return toolResult(text, {
+            status: 'COMPLETE', mode: 'semantic', total: candidates.length, thresholds: {minTokens: tokMin},
+            groups: top.map((item) => ({
+                kind: item.kind, label: item.label, similarity: item.pair.similarity,
+                members: [frags[item.pair.a], frags[item.pair.b]].map((fragment) => ({
+                    file: fragment.file, start: fragment.start, end: fragment.end, tokens: fragment.n, label: fragment.label,
+                })),
+            })),
+        }, {page: {shown: top.length, total: candidates.length, capped: top.length < candidates.length}, completeness: {status: 'COMPLETE'}})
     }
     const analysis = analyzeDuplicateGroups(ctx.repoRoot, ctx.graphPath, args)
     const groups = analysis.groups
     const smallPolicy = tokMin < 30 ? ' Small fragments below 30 tokens require at least 95% similarity and two shared bounded fingerprints.' : ''
     const suppressed = analysis.suppressed
     const suppressionNote = suppressed && !includeClassified
-        ? ` ${suppressed} fragment(s) classified as tests/e2e/generated/mock/story/docs/benchmark/temp or matched by .weavatrix.json exclude were suppressed; pass include_classified:true (and include_tests:true for tests) to inspect them explicitly.`
+        ? ` ${suppressed} fragment(s) classified as tests/e2e/generated/vendored/mock/story/docs/benchmark/temp or matched by .weavatrix.json exclude were suppressed; pass include_classified:true (and include_tests:true for tests) to inspect them explicitly.`
         : ''
     const boilerplateNote = analysis.boilerplateSuppressed
         ? ` ${analysis.boilerplateSuppressed} all-router framework boilerplate group(s) were suppressed; pass include_boilerplate:true to inspect them.`
@@ -69,7 +85,14 @@ export function tFindDuplicates(g, args, ctx) {
     const declarativeNote = analysis.declarativeSuppressed
         ? ` ${analysis.declarativeSuppressed} immutable declarative catalog group(s) were suppressed; pass include_declarative:true to inspect repeated data shapes.`
         : ''
-    if (!groups.length) return `No clones at ≥${simMin}% similarity / ≥${tokMin} tokens (${mode} mode). Try lowering the thresholds.${smallPolicy}${suppressionNote}${boilerplateNote}${declarativeNote}`
+    if (!groups.length) return toolResult(
+        `No clones at ≥${simMin}% similarity / ≥${tokMin} tokens (${mode} mode). Try lowering the thresholds.${smallPolicy}${suppressionNote}${boilerplateNote}${declarativeNote}`,
+        {
+            status: 'COMPLETE', mode, total: 0, groups: [], thresholds: {minSimilarity: simMin, minTokens: tokMin},
+            suppressed: {classifiedFragments: suppressed, boilerplateGroups: analysis.boilerplateSuppressed, declarativeGroups: analysis.declarativeSuppressed},
+        },
+        {page: {shown: 0, total: 0, capped: false}, completeness: {status: 'COMPLETE'}},
+    )
     const top = groups.slice(0, Math.min(30, Math.max(1, Number(args.top_n) || 15)))
     const lines = top.map((grp, k) => {
         const isStr = grp.members.some((f) => f.kind === 'string')
@@ -77,7 +100,20 @@ export function tFindDuplicates(g, args, ctx) {
         const sites = grp.members.slice(0, 8).map((f) => `     ${f.file}:${f.start}-${f.end}`)
         return [head, ...sites].join('\n')
     })
-    return `Found ${groups.length} clone group(s) (${mode} mode, ≥${simMin}%, ≥${tokMin} tok${includeStrings ? ', incl. large string literals' : ''}). Top ${top.length}:\n\n${lines.join('\n\n')}\n\nUse read_source on any two sites to compare, then extract shared logic.${smallPolicy}${suppressionNote}${boilerplateNote}${declarativeNote}`
+    const text = `Found ${groups.length} clone group(s) (${mode} mode, ≥${simMin}%, ≥${tokMin} tok${includeStrings ? ', incl. large string literals' : ''}). Top ${top.length}:\n\n${lines.join('\n\n')}\n\nUse read_source on any two sites to compare, then extract shared logic.${smallPolicy}${suppressionNote}${boilerplateNote}${declarativeNote}`
+    return toolResult(text, {
+        status: 'COMPLETE', mode, total: groups.length, thresholds: {minSimilarity: simMin, minTokens: tokMin},
+        includeStrings,
+        suppressed: {classifiedFragments: suppressed, boilerplateGroups: analysis.boilerplateSuppressed, declarativeGroups: analysis.declarativeSuppressed},
+        groups: top.map((group) => ({
+            similarity: group.maxSim, duplicatedTokens: group.tokens,
+            members: group.members.slice(0, 8).map((fragment) => ({
+                file: fragment.file, start: fragment.start, end: fragment.end, tokens: fragment.n,
+                label: fragment.label, kind: fragment.kind || 'symbol', classes: fragment.classes || [],
+            })),
+            memberCount: group.members.length,
+        })),
+    }, {page: {shown: top.length, total: groups.length, capped: top.length < groups.length}, completeness: {status: 'COMPLETE'}})
 }
 
 // Focused dead-code review queue. Unlike the broad run_audit surface, this includes functions and

package/src/mcp/health/endpoints.mjs

@@ -35,7 +35,7 @@ export function tListEndpoints(g, args, ctx) {
     const suppressed = includeClassified ? 0 : classified.length
     eps = includeClassified ? [...production, ...classified] : production
     const suppressionNote = suppressed
-        ? `${suppressed} endpoint(s) in classified test/e2e/generated/mock/story/docs/benchmark/temp or explicitly excluded paths were suppressed; pass include_classified:true to inspect them.`
+        ? `${suppressed} endpoint(s) in classified test/e2e/generated/vendored/mock/story/docs/benchmark/temp or explicitly excluded paths were suppressed; pass include_classified:true to inspect them.`
         : ''
     if (!eps.length) return suppressed
         ? `No production HTTP endpoints detected; ${suppressionNote}`

package/src/mcp/health/structure.mjs

@@ -31,7 +31,7 @@ export function tModuleMap(g, args, ctx) {
             if (classifiedFiles.has(sourceFile)) continue
             classifiedFiles.add(sourceFile)
             const explanation = classifier.explain(sourceFile)
-            if (explanation.excluded || hasPathClass(explanation, 'test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp')) {
+            if (explanation.excluded || hasPathClass(explanation, 'test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp')) {
                 nonProductFiles.add(sourceFile)
             }
         }
@@ -173,7 +173,9 @@ export function tCoverageMap(g, args, ctx) {
             '  JS/TS:  npx vitest run --coverage   (or jest --coverage)',
             '  Python: pytest --cov --cov-report=json',
             '  Go:     go test ./... -coverprofile=coverage.out',
-            'Read locations: coverage/coverage-summary.json, coverage/coverage-final.json, (coverage/)lcov.info, coverage.json, coverage.out.',
+            '  Rust:   cargo tarpaulin --out Json --output-dir .',
+            '          or cargo llvm-cov --lcov --output-path lcov.info',
+            'Read locations: coverage/coverage-summary.json, coverage/coverage-final.json, (coverage/)lcov.info, coverage.json, tarpaulin-report.json, coverage.out.',
         ].filter((line) => line != null).join('\n')
     }
     const pctStr = (v) => (v == null ? 'n/a' : `${Math.round(v * 100)}%`)
@@ -216,4 +218,3 @@ export function tCoverageMap(g, args, ctx) {
 }
 
 // HTTP endpoint inventory: Express/Fastify/Nest/Flask/FastAPI/Go/Rust/Spring route definitions.
-