feat(analysis): make resource budgets recoverable across CLI and MCP (#9706)

* refactor(analysis): centralize resource budgets and recovery facts

* feat(analysis): expose ASAR and Ghidra runtime admission controls

* feat(artifacts): expose reader admission and preserve limited recognition

* feat(javascript): expose recoverable semantic precision budgets

* feat(web): add recoverable source-map budgets and compact retained views

* feat(web): make historical capture decoding budgets recoverable

* fix(desktop): enforce selected view policies across capture and export

* feat(runtime): make Frida and LLDB retention budgets selectable

* feat(native): expose diagnostic budgets and preserve exhaustion causes

* feat(managed): expose recoverable snapshot and representation budgets

* feat(metadata): make Go and Rust inspection budgets recoverable

* feat(wasm): expose representation and producer admissions

* feat(evm): expose per-call worker resource budgets

* feat(android): make resource and string-pool omissions recoverable

* feat(producers): expose command and recorded-capture budgets

* docs(analysis): record recovery contracts and integrated validation

* fix(docs): link calibration oracle from published verification pages

* fix(docs): restore desktop task anchors and receipt links

* test(analysis): align fixtures with selectable budget contracts

* fix(analysis): remove source-location projector dependency cycle

* test(analysis): refresh budget recovery and verifier regressions

* test(analysis): preserve format and publication recovery expectations

* test(windows): align conformance with owned runtime admission

* fix(desktop): preserve selected alias kinds in exported state

* test(analysis): align provider fixtures with recoverable budgets

* test(desktop): validate emitted alias metadata structurally

* fix(ghidra): classify bounded Windows endpoint refusals

* test(cli): assert selectable artifact admission recovery

* fix(cli): preserve capture provenance in environment builds

tests/boundary/javascript/javascriptSourceAnalysisWorker.test.ts

@@ -110,6 +110,61 @@ it("reuses one real owned analyzer while retaining distinct source identities an
   }
 });
 
+it("recovers finite primitive alternatives after changing precision on the same scope", async () => {
+  const scope = new ArtifactResourceScope();
+  const expression = Array.from(
+    { length: 9 },
+    (_, index) =>
+      `(globalThis.choice${String(index)} ? 0 : ${String(2 ** index)})`,
+  ).join(" + ");
+  const file = source(
+    "precision.mjs",
+    `export function choose() { return ${expression}; }`,
+  );
+  try {
+    for (const selected of [undefined, 512, undefined]) {
+      const worker = await createJavaScriptSourceAnalysis(
+        {
+          heapMb: 128,
+          timeoutMs: 30_000,
+          ...(selected === undefined
+            ? {}
+            : { semanticPrecision: { primitive_candidates: selected } }),
+        },
+        1,
+        { scope },
+      );
+      try {
+        const result = await worker.analyze(file, {
+          nodes: 100,
+          unknowns: 100,
+        });
+        if (!result.ok) throw result.error.error;
+        const value = result.value.module?.callables[0]?.returnSites[0]?.value;
+        if (selected === undefined) {
+          expect(value).toMatchObject({
+            status: "unknown",
+            resourceLimit: "primitive-candidates",
+          });
+        } else {
+          expect(value?.status).toBe("union");
+          if (value?.status !== "union")
+            throw new Error("Expected all finite alternatives");
+          expect(value.values).toHaveLength(512);
+          expect(value.values).toContain(511);
+          expect(result.value.module?.coverage.precision).toMatchObject({
+            primitive_candidates: 512,
+          });
+        }
+      } finally {
+        await worker.close();
+      }
+    }
+  } finally {
+    await scope.close();
+  }
+});
+
 it("reuses one owned worker across analyses on the same resource scope", async () => {
   const scope = new ArtifactResourceScope();
   const launches: number[] = [];