weavatrix 0.3.4 → 0.3.5

package/README.md

@@ -311,6 +311,17 @@ before starting the MCP server for parser-only operation from the first build, o
 `precision:"off"` to `rebuild_graph` / `open_repo`. The MCPB installer exposes the same `lsp` / `off`
 choice as **TypeScript/JavaScript semantic precision**.
 
+The broad prewarm stays conservative by default: it queries 32 ranked symbols and never more than
+64. A deliberate high-budget run can set `WEAVATRIX_PRECISION_MAX_SYMBOLS` above 64 (for example,
+`1000`), or set `WEAVATRIX_PRECISION_PREWARM=full` to select every eligible target up to the hard
+10,000-symbol safety ceiling. Expanded runs receive proportionate reference/link and deadline
+budgets, still capped at 131,072 references/links, a 30-minute deadline, 1,024 open documents and
+128 MiB of verified source. `WEAVATRIX_PRECISION_MAX_REFERENCES`,
+`WEAVATRIX_PRECISION_MAX_LINKS`, and `WEAVATRIX_PRECISION_TIMEOUT_MS` can lower or explicitly tune
+those budgets. Repositories that exceed any hard ceiling remain honestly `PARTIAL`; the default
+memory/time profile is unchanged. On-demand `get_dependents`, `inspect_symbol`, and
+`change_impact` queries remain revision-bound separate caches and do not require a full prewarm.
+
 **search / source** — `search_code` (ripgrep-backed, pure-Node fallback, with repository-relative
 path globs on Windows/macOS/Linux), `read_source` (a
 symbol's actual code in one hop), `context_bundle` (definition plus grouped inbound/outbound
@@ -413,6 +424,19 @@ metrics are not persisted or transmitted by Weavatrix. If a source checkout's pa
 while an old daemon remains alive, `initialize`, `tools/list`, and tool calls fail loudly with
 `STALE_RUNTIME` until the client reconnects; the opt-out is reserved for deliberate development.
 
+### 0.3.5 explicit full semantic prewarm
+
+- Normal startup remains bounded to 32 ranked semantic targets. An explicit
+  `WEAVATRIX_PRECISION_PREWARM=full` run, or a requested symbol budget above
+  64, can now cover every eligible JS/TS target within hard time, source and
+  memory ceilings instead of being silently clamped to 64.
+- Real Hosted dogfood queried all 800 eligible targets in about 49 seconds and
+  produced 4,127 `EXACT_LSP` edges with `COMPLETE` semantic precision.
+- Unreferenced public exports are now reported as low-confidence module-surface
+  evidence, not as proof that their implementations are dead.
+
+Full patch notes: [docs/releases/v0.3.5.md](docs/releases/v0.3.5.md).
+
 ### 0.3.4 self-audit precision and bounded dynamic imports
 
 - JS/TS graph construction now resolves the existing local-file prefix in

package/docs/releases/v0.3.5.md

@@ -0,0 +1,50 @@
+# Weavatrix 0.3.5
+
+0.3.5 removes the hidden 64-symbol ceiling from deliberately high-budget
+TypeScript/JavaScript semantic prewarms while keeping the ordinary offline
+startup profile unchanged.
+
+## Explicit full semantic prewarm
+
+- The default remains a 32-symbol ranked prewarm with the previous 64-symbol,
+  16,384-reference/link and 60-second hard ceilings.
+- Setting `WEAVATRIX_PRECISION_MAX_SYMBOLS` above 64 now explicitly opts into
+  the expanded policy instead of being silently clamped back to 64.
+- `WEAVATRIX_PRECISION_PREWARM=full` selects all eligible targets, bounded by a
+  10,000-symbol hard ceiling. It is intended for CI, release evidence and
+  manually requested deep repository audits, not implicit startup work.
+- Expanded runs scale their default reference/link budget to 16 per requested
+  symbol and their deadline to one second per requested symbol. Hard limits
+  remain 131,072 references/links and 30 minutes.
+- Verified source remains bounded to 4 MiB per file, 1,024 simultaneously open
+  documents and 128 MiB total. Crossing a ceiling remains `PARTIAL`; it never
+  becomes a false complete result or an unbounded allocation.
+
+The point-query cache used by `get_dependents` and `inspect_symbol`, and the
+bounded changed-symbol batch used by `change_impact`, remain separate from this
+broad overlay. Existing default and on-demand behavior is unchanged.
+
+The regression suite proves both sides of the contract: an ordinary build still
+selects 32 of 80 candidates and reports `PARTIAL`, while an explicit 1,000-symbol
+budget and `full` mode each query all 80 targets and report `COMPLETE` with a
+cooperative provider.
+
+## Dead-code verdict consistency
+
+- `run_audit` now labels an unreferenced public export as low-confidence
+  `unused-export-surface` evidence and sets `deadCodeCandidate:false`.
+- The audit explains that an unused module surface is not proof of a dead
+  implementation; downstream packages and runtime registries may be invisible.
+- This matches `find_dead_code`, which keeps the same uncertain public surface
+  out of its default medium-confidence review queue while reporting the
+  suppressed low-confidence count.
+
+## Consistent unused-export confidence
+
+`run_audit` now labels an unused export as low-confidence export-surface
+evidence, not a medium-confidence dead implementation. The finding explicitly
+distinguishes removing an unnecessary export keyword from deleting the symbol,
+which still requires the separate exact/reference-aware `find_dead_code`
+workflow. This aligns Health with the default dead-code queue, where public and
+framework-sensitive candidates are intentionally suppressed until
+`min_confidence=low` is requested.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "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>",
@@ -38,6 +38,7 @@
     "docs/releases/v0.3.2.md",
     "docs/releases/v0.3.3.md",
     "docs/releases/v0.3.4.md",
+    "docs/releases/v0.3.5.md",
     "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",

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

@@ -148,13 +148,16 @@ export async function runInternalAudit(repoPath, {
       category: "unused",
       rule: "unused-export",
       severity: "info",
-      confidence: "medium",
+      confidence: "low",
       title: `Unused export: ${symbol.label.replace(/\(\)$/, "")} — ${symbol.file}`,
-      detail: `${symbol.reason}. Either remove the export keyword (if used only internally) or delete the symbol.`,
+      detail: `${symbol.reason}. This is unused module-surface evidence, not proof that the implementation is dead: downstream packages and runtime registration can be invisible to the repository graph. Review external consumers first; remove only the export keyword when the symbol is still used internally, and delete the implementation only after separate dead-code verification.`,
       file: symbol.file,
       symbol: symbol.label,
       graphNodeId: symbol.id,
       source: "internal",
+      classification: "unused-export-surface",
+      deadCodeCandidate: false,
+      fixHint: "check downstream/runtime consumers, then remove only the export surface or run a separate exact dead-code review before deleting the implementation",
     }));
     unusedExportCount++;
   }

package/src/precision/lsp-overlay/budget-policy.js

@@ -0,0 +1,78 @@
+import {boundedInteger} from '../../bounds.js'
+
+const DEFAULT_MAX_SYMBOLS = 32
+const BOUNDED_MAX_SYMBOLS = 64
+const EXPANDED_MAX_SYMBOLS = 10_000
+const DEFAULT_MAX_REFERENCES = 2_048
+const BOUNDED_MAX_REFERENCES = 16_384
+const EXPANDED_MAX_REFERENCES = 131_072
+const DEFAULT_MAX_LINKS = 2_048
+const BOUNDED_MAX_LINKS = 16_384
+const EXPANDED_MAX_LINKS = 131_072
+const DEFAULT_TIMEOUT_MS = 45_000
+const BOUNDED_MAX_TIMEOUT_MS = 60_000
+const EXPANDED_MAX_TIMEOUT_MS = 30 * 60_000
+
+function configured(value, environmentName) {
+  if (value !== undefined && value !== null && String(value).trim() !== '') return value
+  const environmentValue = process.env[environmentName]
+  return environmentValue != null && String(environmentValue).trim() !== ''
+    ? environmentValue : undefined
+}
+
+export function precisionPrewarmBudget(options = {}) {
+  const targetBatch = Array.isArray(options.targetIds) && options.targetIds.length > 0
+  const configuredMode = String(configured(
+    options.prewarmMode,
+    'WEAVATRIX_PRECISION_PREWARM',
+  ) || 'bounded').trim().toLowerCase()
+  const full = configuredMode === 'full' && !targetBatch
+  const requestedSymbols = configured(options.maxSymbols, 'WEAVATRIX_PRECISION_MAX_SYMBOLS')
+  const numericSymbols = Number(requestedSymbols)
+  const expanded = full || (Number.isFinite(numericSymbols) && numericSymbols > BOUNDED_MAX_SYMBOLS)
+  const maxSymbols = full ? EXPANDED_MAX_SYMBOLS : boundedInteger(
+    requestedSymbols,
+    DEFAULT_MAX_SYMBOLS,
+    1,
+    expanded ? EXPANDED_MAX_SYMBOLS : BOUNDED_MAX_SYMBOLS,
+  )
+  const referenceFallback = expanded
+    ? Math.min(EXPANDED_MAX_REFERENCES, Math.max(DEFAULT_MAX_REFERENCES, maxSymbols * 16))
+    : DEFAULT_MAX_REFERENCES
+  const linkFallback = expanded
+    ? Math.min(EXPANDED_MAX_LINKS, Math.max(DEFAULT_MAX_LINKS, maxSymbols * 16))
+    : DEFAULT_MAX_LINKS
+  const timeoutFallback = expanded
+    ? Math.min(15 * 60_000, Math.max(DEFAULT_TIMEOUT_MS, maxSymbols * 1_000))
+    : DEFAULT_TIMEOUT_MS
+  const maxReferences = boundedInteger(
+    configured(options.maxReferences, 'WEAVATRIX_PRECISION_MAX_REFERENCES'),
+    referenceFallback,
+    1,
+    expanded ? EXPANDED_MAX_REFERENCES : BOUNDED_MAX_REFERENCES,
+  )
+  const maxLinks = boundedInteger(
+    configured(options.maxLinks, 'WEAVATRIX_PRECISION_MAX_LINKS'),
+    linkFallback,
+    1,
+    expanded ? EXPANDED_MAX_LINKS : BOUNDED_MAX_LINKS,
+  )
+  const timeoutMs = boundedInteger(
+    configured(options.timeoutMs, 'WEAVATRIX_PRECISION_TIMEOUT_MS'),
+    timeoutFallback,
+    100,
+    expanded ? EXPANDED_MAX_TIMEOUT_MS : BOUNDED_MAX_TIMEOUT_MS,
+  )
+  return {
+    expanded,
+    full,
+    maxSymbols,
+    maxReferences,
+    maxLinks,
+    timeoutMs,
+    maxOpenDocuments: expanded ? 1_024 : 96,
+    maxOpenBytes: expanded ? 128 * 1024 * 1024 : 32 * 1024 * 1024,
+    maxClassificationDocuments: expanded ? 1_024 : 96,
+    maxClassificationBytes: expanded ? 128 * 1024 * 1024 : 32 * 1024 * 1024,
+  }
+}

package/src/precision/lsp-overlay/build.js

@@ -1,5 +1,5 @@
-import {boundedInteger} from '../../bounds.js'
 import {createTypeScriptLspClient} from '../typescript-lsp-provider.js'
+import {precisionPrewarmBudget} from './budget-policy.js'
 import {baseOverlay} from './contract.js'
 import {precisionOverlayMatches} from './contract.js'
 import {collectReferenceResults} from './reference-results.js'
@@ -106,17 +106,24 @@ function failedOverlay(session, error) {
 }
 
 function createSession(options) {
-  const boundedMax = boundedInteger(options.maxSymbols, 32, 1, 64)
-  const boundedReferences = boundedInteger(options.maxReferences, 2_048, 1, 16_384)
-  const boundedLinks = boundedInteger(options.maxLinks, 2_048, 1, 16_384)
-  const boundedTimeout = boundedInteger(options.timeoutMs, 45_000, 100, 60_000)
+  const budget = precisionPrewarmBudget(options)
   return {
     ...options,
-    boundedMax,
-    boundedReferences,
-    boundedLinks,
-    deadline: Date.now() + boundedTimeout,
-    request: {maxSymbols: boundedMax, maxReferences: boundedReferences, maxLinks: boundedLinks},
+    expandedPrewarm: budget.expanded,
+    fullPrewarm: budget.full,
+    boundedMax: budget.maxSymbols,
+    boundedReferences: budget.maxReferences,
+    boundedLinks: budget.maxLinks,
+    maxOpenDocuments: budget.maxOpenDocuments,
+    maxOpenBytes: budget.maxOpenBytes,
+    maxClassificationDocuments: budget.maxClassificationDocuments,
+    maxClassificationBytes: budget.maxClassificationBytes,
+    deadline: Date.now() + budget.timeoutMs,
+    request: {
+      maxSymbols: budget.maxSymbols,
+      maxReferences: budget.maxReferences,
+      maxLinks: budget.maxLinks,
+    },
     links: [],
     seen: new Set(),
     evidenceSeen: new Set(),
@@ -138,17 +145,18 @@ export async function buildLspPrecisionOverlay({
   graph,
   graphPath,
   mode = 'lsp',
-  maxSymbols = Number(process.env.WEAVATRIX_PRECISION_MAX_SYMBOLS) || 32,
-  maxReferences = Number(process.env.WEAVATRIX_PRECISION_MAX_REFERENCES) || 2_048,
-  maxLinks = Number(process.env.WEAVATRIX_PRECISION_MAX_LINKS) || 2_048,
-  timeoutMs = Number(process.env.WEAVATRIX_PRECISION_TIMEOUT_MS) || 45_000,
+  maxSymbols,
+  maxReferences,
+  maxLinks,
+  timeoutMs,
+  prewarmMode,
   targetIds,
   clientFactory,
 } = {}) {
   if (!graph || !repoRoot) throw new Error('precision overlay requires repoRoot and graph')
   const session = createSession({
     repoRoot, graph, graphPath, mode, maxSymbols, maxReferences, maxLinks,
-    timeoutMs, targetIds, clientFactory,
+    timeoutMs, prewarmMode, targetIds, clientFactory,
   })
   if (mode === 'off') {
     return persist(session, baseOverlay(graph, 'OFF', {

package/src/precision/lsp-overlay/source-session.js

@@ -62,11 +62,15 @@ export async function ensureOpen(session, relPath) {
   const file = norm(relPath)
   if (!file || session.opened.has(file)) return
   ensureBudget(session)
-  if (session.opened.size >= 96) throw new PrecisionLimitError('precision open-document limit reached')
-  const maxBytes = Math.min(4 * 1024 * 1024, 32 * 1024 * 1024 - session.openedBytes)
+  const maxDocuments = Number(session.maxOpenDocuments) || 96
+  const maxOpenBytes = Number(session.maxOpenBytes) || 32 * 1024 * 1024
+  if (session.opened.size >= maxDocuments) {
+    throw new PrecisionLimitError('precision open-document limit reached')
+  }
+  const maxBytes = Math.min(4 * 1024 * 1024, maxOpenBytes - session.openedBytes)
   const {bytes, text} = verifiedSource(session, file, maxBytes)
   if (bytes > 4 * 1024 * 1024) throw new PrecisionLimitError('precision document exceeds 4 MiB limit')
-  if (session.openedBytes + bytes > 32 * 1024 * 1024) {
+  if (session.openedBytes + bytes > maxOpenBytes) {
     throw new PrecisionLimitError('precision source-transfer budget reached')
   }
   await awaitWithBudget(session, () => session.client.openDocument(file, text))
@@ -79,13 +83,15 @@ export function sourceForClassification(session, relPath) {
   const file = norm(relPath)
   if (session.openedTexts.has(file)) return session.openedTexts.get(file)
   if (session.classificationTexts.has(file)) return session.classificationTexts.get(file)
-  if (session.classificationTexts.size >= 96) return null
+  const maxDocuments = Number(session.maxClassificationDocuments) || 96
+  const maxClassificationBytes = Number(session.maxClassificationBytes) || 32 * 1024 * 1024
+  if (session.classificationTexts.size >= maxDocuments) return null
   let source
   try {
     source = verifiedSource(
       session,
       file,
-      Math.min(4 * 1024 * 1024, 32 * 1024 * 1024 - session.classificationBytes),
+      Math.min(4 * 1024 * 1024, maxClassificationBytes - session.classificationBytes),
     )
   } catch (error) {
     if (error instanceof PrecisionLimitError) return null
@@ -100,7 +106,9 @@ export async function ensureFullUniverse(session) {
   if (session.fullUniverseOpened) return true
   if (!session.universe.complete) return false
   const additional = session.universe.files.filter((file) => !session.opened.has(file))
-  if (session.opened.size + additional.length > 96) {
+  const maxDocuments = Number(session.maxOpenDocuments) || 96
+  const maxOpenBytes = Number(session.maxOpenBytes) || 32 * 1024 * 1024
+  if (session.opened.size + additional.length > maxDocuments) {
     session.truncated = true
     return false
   }
@@ -115,7 +123,7 @@ export async function ensureFullUniverse(session) {
     let bytes
     try { bytes = statSync(resolvedFile.path).size }
     catch { throw new PrecisionStaleGraphError() }
-    if (bytes > 4 * 1024 * 1024 || projectedBytes + bytes > 32 * 1024 * 1024) {
+    if (bytes > 4 * 1024 * 1024 || projectedBytes + bytes > maxOpenBytes) {
       session.truncated = true
       return false
     }