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

src/windows/WindowsPrivateRuntime.test.ts

@@ -392,13 +392,14 @@ it("retains bound refusal and failed file close until the same owner recovers",
   expect(closes).toBe(2);
 });
 
-it.each(["valid", "oversized"] as const)(
+it.each(["valid", "oversized", "oversized-close-failed"] as const)(
   "observes a %s Windows Ghidra endpoint through its owning runtime",
   async (kind) => {
     const { observeGhidraEndpoint } =
       await import("../ghidra/GhidraTransport.js");
     const valid = Buffer.from('{"host":"127.0.0.1","port":65535}\n');
     const operations: string[] = [];
+    let fileCloses = 0;
     nativeCall.mockImplementation((operation: string) => {
       operations.push(operation);
       if (operation === "runtime_create") return observation;
@@ -408,6 +409,12 @@ it.each(["valid", "oversized"] as const)(
           size: kind === "valid" ? valid.length : valid.length + 1,
         };
       if (operation === "read") return valid;
+      if (
+        operation === "close" &&
+        kind === "oversized-close-failed" &&
+        fileCloses++ === 0
+      )
+        throw nativeFailure(5);
       return null;
     });
     const runtime = WindowsPrivateRuntime.create("C:\\", "rea-");
@@ -430,8 +437,26 @@ it.each(["valid", "oversized"] as const)(
           value: { host: "127.0.0.1", port: 65535 },
         });
       else {
-        expect(result.ok).toBe(false);
+        expect(result).toMatchObject({
+          ok: false,
+          error: {
+            kind: "start",
+            message: "Ghidra TCP endpoint is invalid",
+            cause: { reason: "limit" },
+          },
+        });
         expect(operations).not.toContain("read");
+        if (kind === "oversized-close-failed") {
+          if (result.ok) throw new Error("Expected endpoint admission failure");
+          const cleanup = result.error.cleanupFailure;
+          expect(cleanup?.cleanupIncomplete).toBe(true);
+          expect(cleanup?.cleanupResources).toEqual([
+            admittedFile.requestedPath,
+          ]);
+          expect(windowsPrivateRuntime(observation.path)).toBe(runtime);
+          await runtime.close();
+          expect(cleanup?.cleanupIncomplete).toBe(false);
+        }
       }
       expect(operations).toContain("close");
     } finally {