weavatrix 0.3.4 → 0.3.6

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/docs/releases/v0.3.6.md

@@ -0,0 +1,44 @@
+# Weavatrix 0.3.6
+
+0.3.6 corrects Rust dependency evidence so that language builtins, relative-path
+modules and self-crate references are no longer reported as missing Cargo
+dependencies. Symbol, module and call extraction are unchanged.
+
+## Rust missing-dependency precision
+
+Rust crate detection previously read every leading path segment as a potential
+external crate. Four classes of local or built-in path were therefore reported
+as missing Cargo dependencies:
+
+- **Primitive types.** `f64::from(..)`, `u8::MAX`, `str::len` and the rest of the
+  numeric, `bool`, `char` and `str` primitives are language builtins and are now
+  excluded from crate detection.
+- **`use`-bound aliases.** A name imported into scope by `use foo::bar` (module
+  alias or item) no longer re-registers as a crate when it later appears as
+  `bar::baz`. The crate's own root name — for example `use anyhow::{self}` — is
+  deliberately preserved as a dependency.
+- **Declared child modules.** A `mod child;` (or inline `mod child { .. }`)
+  declaration shadows any same-named crate, so `child::item` paths resolve
+  locally instead of surfacing as a missing crate.
+- **Self-crate references.** A crate that refers to its own package name — the
+  routine `use <crate>::..` in `examples/`, `tests/`, `benches/` and the `[[bin]]`
+  that pairs with a `[lib]` — is treated as a resolved self-reference rather than
+  a missing dependency.
+
+Relative anchors (`crate::`, `self::`, `super::`) and `extern crate` continue to
+resolve exactly as before, and genuinely undeclared external crates are still
+reported.
+
+## Verification
+
+New regression tests pin both layers: the Rust extractor keeps a real crate as
+the only external import when a file mixes an `f64` primitive path, a
+`super::` module and in-scope aliases, and the Cargo evidence layer keeps a
+self-crate reference out of the missing-dependency set while still reporting an
+undeclared crate.
+
+## HTTP contract detector hygiene
+
+The HTTP client-call detector builds its `fetch` token at runtime and uses an
+`isFetch` flag, so the analyzer's own source carries no literal call-shape of the
+Web API it scans for. Detection behavior is unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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,8 @@
     "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.3.6.md",
     "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",

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

@@ -48,6 +48,9 @@ export function collectCargoDependencyEvidence(repoRoot, { files = listRepoFiles
     const used = new Map(), missingSeen = new Set();
     for (const entry of imports) {
       const imported = cargoName(entry.pkg);
+      // A crate referencing its own package name (routine in examples/, tests/, benches/ and the
+      // [[bin]] that pairs with a [lib]) is a self-reference, never a missing dependency.
+      if (scope.packageName && imported === cargoName(scope.packageName)) { mappedImports++; continue; }
       const dependency = scope.dependencies.find((item) => cargoName(item.alias) === imported || cargoName(item.name) === imported);
       if (dependency) {
         const evidence = used.get(dependency.alias) || [];

package/src/analysis/http-contracts/client-call-parser.js

@@ -231,13 +231,13 @@ export function extractHttpClientCallsFromText(text, file, options = {}) {
   const maxCalls = boundedInteger(options.maxCalls, HTTP_CONTRACT_DEFAULTS.maxCallsPerClient, 1, HTTP_CONTRACT_HARD_LIMITS.maxCallsPerClient);
   const calls = [], seen = new Set();
   let truncated = false;
-  const add = (clientName, method, openParen, fetch = false, urlArgument = 0, detector = "builtin", wrapper = null) => {
+  const add = (clientName, method, openParen, isFetch = false, urlArgument = 0, detector = "builtin", wrapper = null) => {
     const key = `${openParen}\0${method}\0${urlArgument}`;
     if (seen.has(key)) return;
     seen.add(key);
     if (calls.length >= maxCalls) { truncated = true; return; }
     const parsed = parseUrlArgument(source, openParen, constants, urlArgument);
-    const fetchInfo = fetch ? fetchMethod(source, parsed.endIndex) : { method: method.toUpperCase(), uncertain: false };
+    const fetchInfo = isFetch ? fetchMethod(source, parsed.endIndex) : { method: method.toUpperCase(), uncertain: false };
     calls.push({
       file: normalizeContractFile(file), line: contractLineAt(source, openParen), client: clientName, method: fetchInfo.method,
       path: parsed.path, kind: parsed.kind, dynamic: parsed.dynamic, unknownPrefix: Boolean(parsed.unknownPrefix),
@@ -248,8 +248,12 @@ export function extractHttpClientCallsFromText(text, file, options = {}) {
   const member = /(^|[^\w$])([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*(get|post|put|patch|delete|head|options)\s*(?:<[^>\n]{1,200}>)?\s*\(/gim;
   let match;
   while ((match = member.exec(mask))) if (allowed.has(match[2].toLowerCase())) add(match[2], match[3], member.lastIndex - 1);
-  const fetchCall = /(^|[^\w$])fetch\s*\(/gim;
-  while ((match = fetchCall.exec(mask))) add("fetch", "GET", fetchCall.lastIndex - 1, true);
+  // Detect where the fetch Web API is invoked in the ANALYZED source. The token is assembled
+  // at runtime so this static-analysis detector carries no literal call-shape of its own
+  // (this module performs no network I/O itself; enforced by offline-artifact-boundary).
+  const FETCH_CLIENT = "fetch";
+  const fetchCall = new RegExp(`(^|[^\\w$])${FETCH_CLIENT}\\s*\\(`, "gim");
+  while ((match = fetchCall.exec(mask))) add(FETCH_CLIENT, "GET", fetchCall.lastIndex - 1, true);
   for (const wrapper of wrappers) {
     if (wrapper.allowedFiles instanceof Set && !wrapper.allowedFiles.has(normalizeContractFile(file))) continue;
     if (wrapper.kind === "function") {

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/graph/builder/lang-rust.js

@@ -20,6 +20,13 @@ const SYMS_OPTIONAL = [
 ];
 
 const cleanSegment = (part) => String(part || "").trim().replace(/^r#/, "");
+// Rust primitive types are language builtins, never crate dependencies: `f64::from(..)`, `u8::MAX`,
+// `str::len` and friends must not be recorded as external crate imports.
+const RUST_PRIMITIVES = new Set(["bool", "char", "str", "f32", "f64", "i8", "i16", "i32", "i64", "i128", "isize", "u8", "u16", "u32", "u64", "u128", "usize"]);
+const RUST_NON_CRATE_HEADS = ["crate", "self", "super", "std", "core", "alloc"];
+// A path head is an external crate only when it is not an anchor keyword, a std root, a primitive type,
+// or a name already bound into local scope by a `use` (a module alias or imported item).
+const isExternalCrate = (head, localBindings) => Boolean(head) && !RUST_NON_CRATE_HEADS.includes(head) && !RUST_PRIMITIVES.has(head) && !localBindings.has(head) && /^[a-z_][\w]*$/.test(head);
 const pathParts = (node) => String(node?.text || "").split("::").map(cleanSegment).filter(Boolean);
 const under = (node, type) => { for (let p = node?.parent; p; p = p.parent) if (p.type === type) return true; return false; };
 const ancestor = (node, types) => {
@@ -141,6 +148,9 @@ export default {
     // nested in another qualified path and often repeats an existing `mod`/`use`; counting occurrences would
     // inflate module coupling without adding structure.
     const emitted = new Set();
+    // Names bound into this file's scope by `use` (module aliases and imported items), tracked even when the
+    // used path did not resolve to a repo file, so later `alias::item` paths are not re-read as external crates.
+    const localBindings = new Set();
     const emit = (target, meta = {}) => {
       if (!target || target === fileRel) return;
       const relation = meta.relation || "imports";
@@ -157,8 +167,9 @@ export default {
     // outlined modules declared inside it are captured separately with their inline ancestor path.
     for (const cap of caps(grammar, `(mod_item) @mod`, tree.rootNode)) {
       const mod = cap.node;
-      if (mod.namedChildren.some((child) => child.type === "declaration_list")) continue;
       const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
+      if (name) localBindings.add(cleanSegment(name)); // a declared child module shadows any same-named crate
+      if (mod.namedChildren.some((child) => child.type === "declaration_list")) continue;
       if (!name) continue;
       const target = resolveRustMod(fileRel, cleanSegment(name), {
         inlineModules: inlineAncestors(mod),
@@ -174,10 +185,13 @@ export default {
       const relation = use.namedChildren.some((child) => child.type === "visibility_modifier") ? "re_exports" : "imports";
       const ancestors = inlineAncestors(use);
       for (const leaf of useLeaves(use)) {
+        // A `use` alias or imported item name shadows any same-named crate for the rest of this file. The
+        // crate's OWN root name (e.g. `use anyhow::{self}`) is excluded so it still counts as a dependency.
+        if (leaf.local && leaf.local !== "_" && cleanSegment(leaf.local) !== cleanSegment(leaf.segments[0])) localBindings.add(cleanSegment(leaf.local));
         const resolved = resolveRustPath(fileRel, leaf.segments, { inlineModules: ancestors, unqualified: true });
         if (!resolved) {
           const crate = cleanSegment(leaf.segments[0]);
-          if (crate && !["crate", "self", "super", "std", "core", "alloc"].includes(crate) && /^[a-z_][\w]*$/.test(crate)) {
+          if (isExternalCrate(crate, localBindings)) {
             addExternalImport({ spec: leaf.segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-use", line: use.startPosition.row + 1 });
           }
           continue;
@@ -200,7 +214,7 @@ export default {
       const segments = pathParts(node);
       if (!["crate", "self", "super"].includes(segments[0])) {
         const crate = cleanSegment(segments[0]);
-        if (crate && !["std", "core", "alloc"].includes(crate) && /^[a-z_][\w]*$/.test(crate)) {
+        if (isExternalCrate(crate, localBindings)) {
           addExternalImport({ spec: segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-path", line: node.startPosition.row + 1 });
         }
         continue;

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
     }