diff --git a/docs/development/testing.md b/docs/development/testing.md index 372f9c99b0..b75654852b 100644 --- a/docs/development/testing.md +++ b/docs/development/testing.md @@ -876,7 +876,12 @@ holds a late handshake or in-flight work at a boundary and releases it with a value or a rejection, `phaseArrival` marks a boundary whose work waits on something else (an abort, another owner), `cancelDuringCleanup` cancels from inside final cleanup, and `controlledCleanup` gives children -refused or confirmed outcomes with counted retries. Check server +refused or confirmed outcomes with counted retries. +`tests/support/providerLifecycleCoverage.ts` maps every registered provider id +to its launch, handshake, operation, cancellation, cleanup and retry +regressions, a not-applicable reason, or an explicit gap. Name the test file +and literal title when a change adds or moves a provider lifecycle regression; +the shrink-only gap list closes as stages gain coverage. Check server settlement and retained resources even if the MCP SDK rejects the client promise before the handler finishes. A cancellation during active execution does not cover cancellation during final cleanup. diff --git a/tests/boundary/captures/captureProvider.test.ts b/tests/boundary/captures/captureProvider.test.ts index 116492b485..21897e95f6 100644 --- a/tests/boundary/captures/captureProvider.test.ts +++ b/tests/boundary/captures/captureProvider.test.ts @@ -62,6 +62,7 @@ else { if(readFileSync('capture', 'utf8') !== 'recording bytes') throw Error('wr const controller = new AbortController(); let calls = 0; let mayClean = !failCleanup; + let mayStopDecoder = mode !== "process-cleanup"; const acquired = createDeferred(); const release = createDeferred(); const provider = new TsharkCaptureProvider( @@ -99,6 +100,15 @@ else { if(readFileSync('capture', 'utf8') !== 'recording bytes') throw Error('wr }); if (mode === "wait" && !input.arguments.includes("--version")) spawned.process.stdout?.once("data", () => controller.abort()); + if (mode === "process-cleanup" && !input.arguments.includes("--version")) + return { + ...spawned, + // The decoder exits by itself; only the cleanup proof is withheld. + cleanup: async () => + mayStopDecoder + ? { cleaned: true, signaled: false } + : { cleaned: false, reason: "decoder owner remains unverified" }, + }; return spawned; }, async () => { @@ -140,6 +150,7 @@ else { if(readFileSync('capture', 'utf8') !== 'recording bytes') throw Error('wr onTestFinished(async () => { release.resolve(); mayClean = true; + mayStopDecoder = true; await provider.close(); }); const service = new PacketCaptureService(provider); @@ -153,6 +164,7 @@ else { if(readFileSync('capture', 'utf8') !== 'recording bytes') throw Error('wr release: () => release.resolve(), allowCleanup: () => { mayClean = true; + mayStopDecoder = true; }, }; }; @@ -547,6 +559,27 @@ it("retains a completed observation and cleanup ownership for retry", async () = ).toEqual([]); }); +it("releases a retained decoder process cleanup before the next inspection completes", async () => { + const f = await fixture("process-cleanup"); + const input = { path: f.path, fields: ["ip.addr"] }; + const first = await f.service.inspect(input); + if (first.ok) throw new Error("Expected retained process cleanup"); + expect(first.error.cleanupIncomplete).toBe(true); + expect(first.error.cleanupResources).toContainEqual( + expect.stringMatching(/^process-group:\d+$/), + ); + const launches = f.calls(); + const blocked = await f.service.inspect(input); + if (blocked.ok) throw new Error("Expected the retained owner to block"); + expect(blocked.error.cleanupIncomplete).toBe(true); + expect(f.calls()).toBe(launches); + f.allowCleanup(); + const retried = await f.service.inspect(input); + expect(retried.ok).toBe(true); + expect(first.error.cleanupIncomplete).toBe(false); + expect(f.calls()).toBeGreaterThan(launches); +}); + it("rejects cancelled and invalid requests before any provider work", async () => { const f = await fixture(); for (const input of [ diff --git a/tests/boundary/signals/recordingProvider.test.ts b/tests/boundary/signals/recordingProvider.test.ts index d5fa92dfe3..8c357c81cc 100644 --- a/tests/boundary/signals/recordingProvider.test.ts +++ b/tests/boundary/signals/recordingProvider.test.ts @@ -107,6 +107,7 @@ const fixture = async ( const controller = new AbortController(); let calls = 0; let mayClean = !failCleanup; + let mayStopDecoder = mode !== "process-cleanup"; const acquired = createDeferred(); const release = createDeferred(); const provider = new SigrokRecordingProvider( @@ -145,6 +146,15 @@ const fixture = async ( }); if (mode === "wait" && !input.arguments.includes("--version")) spawned.process.stdout?.once("data", () => controller.abort()); + if (mode === "process-cleanup" && !input.arguments.includes("--version")) + return { + ...spawned, + // The decoder exits by itself; only the cleanup proof is withheld. + cleanup: async () => + mayStopDecoder + ? { cleaned: true, signaled: false } + : { cleaned: false, reason: "decoder owner remains unverified" }, + }; return spawned; }, async () => { @@ -184,6 +194,7 @@ const fixture = async ( onTestFinished(async () => { release.resolve(); mayClean = true; + mayStopDecoder = true; await provider.close(); }); const service = new SignalRecordingService(provider); @@ -197,6 +208,7 @@ const fixture = async ( release: () => release.resolve(), allowCleanup: () => { mayClean = true; + mayStopDecoder = true; }, }; }; @@ -1033,6 +1045,27 @@ it("retains a completed observation and cleanup ownership for retry", async () = ).toEqual([]); }); +it("releases a retained decoder process cleanup before the next decode completes", async () => { + const f = await fixture("process-cleanup"); + const input = { path: f.path, decoders: "uart" }; + const first = await f.service.decode(input); + if (first.ok) throw new Error("Expected retained process cleanup"); + expect(first.error.cleanupIncomplete).toBe(true); + expect(first.error.cleanupResources).toContainEqual( + expect.stringMatching(/^process-group:\d+$/), + ); + const launches = f.calls(); + const blocked = await f.service.decode(input); + if (blocked.ok) throw new Error("Expected the retained owner to block"); + expect(blocked.error.cleanupIncomplete).toBe(true); + expect(f.calls()).toBe(launches); + f.allowCleanup(); + const retried = await f.service.decode(input); + expect(retried.ok).toBe(true); + expect(first.error.cleanupIncomplete).toBe(false); + expect(f.calls()).toBeGreaterThan(launches); +}); + it("rejects cancelled and invalid requests before any provider work", async () => { const f = await fixture(); for (const input of [ diff --git a/tests/composition/reverseEngineeringEdgeCases.test.ts b/tests/composition/reverseEngineeringEdgeCases.test.ts index 71317b0310..53b3bd189c 100644 --- a/tests/composition/reverseEngineeringEdgeCases.test.ts +++ b/tests/composition/reverseEngineeringEdgeCases.test.ts @@ -838,6 +838,69 @@ it("releases a retained provider owner after cleanup succeeds", async () => { } }); +it("retains an objdump command's unverified process owner until a later inspection stops it", async () => { + const { directory, path } = await createArtifact(); + let stopped = false; + const cleanupOwner = { + stop: vi.fn(async () => + stopped + ? { status: "verified-cleanup" as const } + : { status: "incomplete" as const, reason: "objdump group remains" }, + ), + } as unknown as ProviderProcessSupervisor; + const runOwned = vi + .fn() + .mockRejectedValueOnce( + new OwnedCommandFailure( + "process", + "objdump cleanup could not be verified", + providerSnapshot({ exitCode: null }), + "objdump group remains", + undefined, + ["run-id", "pid:42"], + cleanupOwner, + ), + ) + .mockResolvedValue(providerSnapshot()); + const service = new ReverseEngineeringService({ runOwned }); + + try { + const first = await service.inspectWithObjdump({ + path, + operation: "symbols", + }); + if (first.ok) throw new Error("Expected retained objdump cleanup"); + expect(first.error.cleanupIncomplete).toBe(true); + expect(first.error.cleanup).toMatchObject({ + reason: "objdump group remains", + resources: ["run-id", "pid:42"], + }); + + const blocked = await service.inspectWithObjdump({ + path, + operation: "symbols", + }); + expect(blocked).toMatchObject({ + ok: false, + error: { cleanupIncomplete: true }, + }); + expect(runOwned).toHaveBeenCalledOnce(); + + stopped = true; + const recovered = await service.inspectWithObjdump({ + path, + operation: "symbols", + }); + if (!recovered.ok) throw recovered.error; + expect(first.error.cleanupIncomplete).toBe(false); + expect(cleanupOwner.stop).toHaveBeenCalledTimes(2); + expect(runOwned).toHaveBeenCalledTimes(2); + } finally { + await service.close().catch(() => undefined); + await rm(directory, { recursive: true, force: true }); + } +}); + it("retains a capability failure when its injected owned runner also reports incomplete cleanup", async () => { const { directory, path } = await createArtifact(); const capability = new AnalysisCapabilityUnavailableError( diff --git a/tests/evaluation/providerLifecycleCoverage.test.ts b/tests/evaluation/providerLifecycleCoverage.test.ts new file mode 100644 index 0000000000..26c36a7861 --- /dev/null +++ b/tests/evaluation/providerLifecycleCoverage.test.ts @@ -0,0 +1,74 @@ +import { readFile } from "node:fs/promises"; +import { expect, it } from "vitest"; +import { CAPABILITY_DECLARATIONS } from "../../src/composition/capabilityDeclarations.js"; +import { + LIFECYCLE_STAGES, + PROVIDER_LIFECYCLE_COVERAGE, + PROVIDER_LIFECYCLE_GAPS, +} from "../support/providerLifecycleCoverage.js"; + +const repositoryRoot = new URL("../../", import.meta.url); + +const registeredProviderIds = () => + [ + ...new Set( + Object.values(CAPABILITY_DECLARATIONS).flatMap((declaration) => + declaration.providers.map((provider) => provider.identity.id), + ), + ), + ].sort(); + +const tableGaps = () => + Object.entries(PROVIDER_LIFECYCLE_COVERAGE).flatMap(([id, entry]) => + LIFECYCLE_STAGES.filter((stage) => entry.stages[stage].kind === "gap").map( + (stage) => `${id}:${stage}`, + ), + ); + +it("has exactly one entry per registered provider id", () => { + expect(Object.keys(PROVIDER_LIFECYCLE_COVERAGE).sort()).toEqual( + registeredProviderIds(), + ); +}); + +it("names an existing test file and literal test title for every covered stage", async () => { + const missing: string[] = []; + const sources = new Map>(); + const source = (path: string) => { + let pending = sources.get(path); + if (pending === undefined) { + pending = readFile(new URL(path, repositoryRoot), "utf8").catch( + (cause: unknown) => { + if ((cause as NodeJS.ErrnoException).code === "ENOENT") + return undefined; + throw cause; + }, + ); + sources.set(path, pending); + } + return pending; + }; + for (const [id, entry] of Object.entries(PROVIDER_LIFECYCLE_COVERAGE)) { + for (const stage of LIFECYCLE_STAGES) { + const coverage = entry.stages[stage]; + if (coverage.kind !== "covered") continue; + for (const { path, title } of coverage.tests) { + const text = await source(path); + if (!path.endsWith(".test.ts") || text === undefined) { + missing.push(`${id}:${stage} missing file ${path}`); + continue; + } + const literal = ['"', "'", "`"].some((quote) => + text.includes(`${quote}${title}${quote}`), + ); + if (!literal) + missing.push(`${id}:${stage} missing title in ${path}: ${title}`); + } + } + } + expect(missing).toEqual([]); +}); + +it("lists exactly the gap stages in the shrink-only gap list", () => { + expect([...PROVIDER_LIFECYCLE_GAPS].sort()).toEqual(tableGaps().sort()); +}); diff --git a/tests/support/providerLifecycleCoverage.ts b/tests/support/providerLifecycleCoverage.ts new file mode 100644 index 0000000000..a1aa5053d3 --- /dev/null +++ b/tests/support/providerLifecycleCoverage.ts @@ -0,0 +1,2003 @@ +/** + * Lifecycle regression coverage for every provider id in + * `CAPABILITY_DECLARATIONS`. + * + * Each stage either names real regression tests (file and literal test title), + * is not applicable for a stated reason, or is an explicit gap. Gaps are also + * listed in `PROVIDER_LIFECYCLE_GAPS`; that list may only shrink, so closing a + * gap means naming its tests here and removing the gap entry. A newly + * registered provider must add its own entry. + * + * Stages: `launch` starts the owned process (including launch failure and + * refusal at the launch boundary); `handshake` is the first readiness or + * identity exchange after launch; `operation` is a completed analysis request; + * `cancel` is caller cancellation of admitted work; `cleanup` retains and + * reports a failed or unproven cleanup; `retry` releases a retained cleanup on + * a later attempt. + * + * Providers that run in-process (no owned process or connection) are tracked + * for operation and cancellation only. Their descriptor and snapshot cleanup + * belongs to the resource owners' own tests. + */ + +export const LIFECYCLE_STAGES = [ + "launch", + "handshake", + "operation", + "cancel", + "cleanup", + "retry", +] as const; + +export type LifecycleStage = (typeof LIFECYCLE_STAGES)[number]; + +export interface LifecycleRegression { + /** Repository-relative test file. */ + readonly path: string; + /** Literal title of a test in that file. */ + readonly title: string; +} + +export type StageCoverage = + | { + readonly kind: "covered"; + readonly tests: readonly [LifecycleRegression, ...LifecycleRegression[]]; + } + | { readonly kind: "not_applicable"; readonly reason: string } + | { readonly kind: "gap"; readonly reason: string }; + +export type ProviderOwnership = "process" | "connection" | "in_process"; + +export interface ProviderLifecycleCoverage { + readonly ownership: ProviderOwnership; + readonly stages: Readonly>; +} + +const test = (path: string, title: string): LifecycleRegression => ({ + path, + title, +}); +const covered = ( + first: LifecycleRegression, + ...rest: LifecycleRegression[] +): StageCoverage => ({ kind: "covered", tests: [first, ...rest] }); +const notApplicable = (reason: string): StageCoverage => ({ + kind: "not_applicable", + reason, +}); +const gap = (reason: string): StageCoverage => ({ kind: "gap", reason }); + +const ONE_SHOT = notApplicable( + "One-shot command per request: there is no handshake after launch.", +); +const ATTACH_ONLY = notApplicable( + "Attaches to a caller-started engine endpoint; REA launches no process.", +); +const IN_PROCESS = notApplicable( + "In-process provider: no owned process or connection to launch, hand shake with, clean up or retry.", +); + +const inProcess = ( + operation: StageCoverage, + cancel: StageCoverage, +): ProviderLifecycleCoverage => ({ + ownership: "in_process", + stages: { + launch: IN_PROCESS, + handshake: IN_PROCESS, + operation, + cancel, + cleanup: IN_PROCESS, + retry: IN_PROCESS, + }, +}); + +const typedFailures = (path: string) => + covered(test(path, "returns typed resource and cancellation failures")); + +const HISTORICAL_DECODER = + "tests/boundary/browser/historicalCaptureDecoder.test.ts"; +/** HAR, qlog, SAZ and mitmproxy captures share one owned decoder child. */ +const historicalCapture = ( + operation: StageCoverage, +): ProviderLifecycleCoverage => ({ + ownership: "process", + stages: { + launch: covered( + test( + HISTORICAL_DECODER, + "cancels after snapshot acquisition before launch and removes private input declarations", + ), + ), + handshake: notApplicable( + "The decoder child writes one reply per request; there is no handshake.", + ), + operation, + cancel: covered( + test( + HISTORICAL_DECODER, + "preserves the exact cancellation reason observed during final runtime close", + ), + ), + cleanup: covered( + test( + HISTORICAL_DECODER, + "retains completed capture facts and binds final root cleanup to its retry lease", + ), + ), + retry: covered( + test( + HISTORICAL_DECODER, + "keeps late cancellation primary when runtime close also fails, then clears on retry", + ), + ), + }, +}); + +const FIRMWARE_INTEGRATION = + "tests/boundary/firmware/firmwareIntegration.test.ts"; +const REVERSE_LAUNCH_ERRORS = + "tests/composition/reverseProviderLaunchErrors.test.ts"; +const REVERSE_EDGE_CASES = + "tests/composition/reverseEngineeringEdgeCases.test.ts"; +const SOURCE_MAP_DECODER_BOUNDARY = + "tests/boundary/javascript/sourceMapDecoder.test.ts"; +const CDP_BROWSER_SOCKET = + "tests/boundary/browser/cdpBrowserProvider.browserSocket.test.ts"; +const CDP_CLEANUP_CANCELLATION = + "tests/boundary/browser/cdpCleanupCancellation.test.ts"; + +export const PROVIDER_LIFECYCLE_COVERAGE: Readonly< + Record +> = { + adb: { + ownership: "process", + stages: { + launch: covered( + test( + "src/adb/AdbCommand.test.ts", + "reports an adb that never started without claiming an exit code", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "src/adb/AdbProvider.test.ts", + "pulls one device file with a digest", + ), + ), + cancel: covered( + test( + "src/adb/AdbProvider.test.ts", + "reports cancellation arriving during the version probe", + ), + ), + cleanup: covered( + test( + "src/adb/AdbProvider.test.ts", + "retains failed snapshot cleanup with completed push Evidence until close retries", + ), + ), + retry: covered( + test( + "src/adb/AdbProvider.test.ts", + "retains failed snapshot cleanup with completed push Evidence until close retries", + ), + ), + }, + }, + "aioquic-qlog-json": historicalCapture( + gap( + "Successful qlog decoding is covered at the parser; no regression completes it through the decoder child.", + ), + ), + "apk-signature": inProcess( + covered( + test( + "tests/boundary/filesystem/apkSignatureViewIdentity.test.ts", + "checks parent subject identity again when signing facts are already cached", + ), + ), + covered( + test( + "tests/process-global/apkSignatureLifecycle.test.ts", + "keeps the abort reason itself as the cancellation cause", + ), + ), + ), + apktool: { + ownership: "process", + stages: { + launch: covered( + test( + "src/apktool/ApktoolProvider.test.ts", + "reports launcher disappearance after version admission as a provider failure", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "src/apktool/ApktoolProvider.test.ts", + "decodes resources with target identity, metadata, and strings", + ), + ), + cancel: covered( + test( + "src/apktool/ApktoolVersionProbe.lifecycle.test.ts", + "stops an interpreter launcher and its pipe-holding child when the probe is cancelled", + ), + ), + cleanup: covered( + test( + "src/apktool/ApktoolProvider.test.ts", + "retains completed Evidence and live cleanup until a denied workspace removal recovers", + ), + ), + retry: covered( + test( + "src/apktool/ApktoolProvider.test.ts", + "retains failed workspace cleanup and retries it on close", + ), + ), + }, + }, + binwalk: { + ownership: "process", + stages: { + launch: covered( + test( + "src/firmware/FirmwareCommand.test.ts", + "does not relabel an unrelated launch failure when a deadline also fires", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + FIRMWARE_INTEGRATION, + "binds region observations to exact bytes and preserves provider-reported uncertainty", + ), + ), + cancel: covered( + test( + FIRMWARE_INTEGRATION, + "cancels an owned active process and permits the next queued operation", + ), + ), + cleanup: covered( + test( + FIRMWARE_INTEGRATION, + "retains an uncertain worker's workspace and blocks later launches", + ), + ), + retry: covered( + test( + "tests/boundary/firmware/firmwareReportFiles.test.ts", + "retains the analysis timeout and command output while report cleanup is pending and after retry", + ), + ), + }, + }, + "byte-entropy": inProcess( + covered( + test( + "src/application/binaryDiagnostics/ByteEntropyService.test.ts", + "keeps whole-file identity and entropy while selecting unaligned blocks and a partial tail", + ), + ), + covered( + test( + "src/application/binaryDiagnostics/ByteEntropyService.test.ts", + "honors cancellation before and during streaming", + ), + ), + ), + "cutter.python-plugin": { + ownership: "connection", + stages: { + launch: ATTACH_ONLY, + handshake: covered( + test( + "tests/boundary/providers/cutterBridgeProducer.test.ts", + "authenticates bridge peers before payloads and permits status recovery after a poisoned UI timeout", + ), + ), + operation: covered( + test( + "tests/boundary/mcp/cutterMcp.test.ts", + "preserves live Cutter command Evidence and parity through the MCP boundary", + ), + ), + cancel: covered( + test( + "tests/boundary/mcp/cutterCancellationMcp.test.ts", + "propagates MCP cancellation into an active Cutter command", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/CutterBridgeService.test.ts", + "clears a poisoned command only after its exact UI-dispatcher receipt", + ), + ), + retry: covered( + test( + "tests/boundary/providers/cutterBridgeProducer.test.ts", + "retains failed receipt acknowledgements and retries before another command", + ), + ), + }, + }, + "electron-fuses": inProcess( + covered( + test( + "tests/acceptance/electronFusesCli.test.ts", + "retains Windows drive, root, and mixed-separator path resolution", + ), + ), + covered( + test( + "src/electron/ElectronFuseCleanup.test.ts", + "retains the exact caller reason and completed Evidence when final close succeeds after cancellation", + ), + ), + ), + "evmole-interface": { + ownership: "process", + stages: { + launch: covered( + test( + "src/evm/EvmoleFailures.test.ts", + "maps real selected-path failures before the EVM worker starts", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/evm/evmoleInterfaceProvider.test.ts", + "retains raw metadata and ordered duplicate selector inferences after worker admission", + ), + ), + cancel: covered( + test( + "tests/boundary/evm/evmCleanupRetry.test.ts", + "preserves an active cancellation through denied owned-group cleanup and later retry", + ), + ), + cleanup: covered( + test( + "tests/boundary/evm/evmoleInterfaceProvider.test.ts", + "retains original format failure when owned-root cleanup fails", + ), + ), + retry: covered( + test( + "src/evm/EvmoleInterfaceProvider.test.ts", + "retains a real cleanup owner through failed EVM close and releases it on retry", + ), + ), + }, + }, + "fiddler-saz": historicalCapture( + covered( + test( + "tests/boundary/browser/sazWebCapture.test.ts", + "uses HTTP optional whitespace for SAZ identity codings without changing raw headers", + ), + ), + ), + flutter: inProcess( + covered( + test( + "tests/boundary/filesystem/flutterBuildProvider.test.ts", + "inspects a full synthetic AOT image end to end", + ), + ), + covered( + test( + "tests/boundary/filesystem/flutterBuildProvider.test.ts", + "cancels before creating any snapshot root", + ), + ), + ), + frida: { + ownership: "process", + stages: { + launch: covered( + test( + "src/frida/FridaInstrumentationManager.test.ts", + "retains a failed startup's spawn and remote lease until cleanup succeeds", + ), + ), + handshake: notApplicable( + "Frida runs in-process through its Node bindings; device and session attach is the launch stage.", + ), + operation: covered( + test( + "src/frida/FridaInstrumentationManager.test.ts", + "loads instrumentation before resuming a spawned target", + ), + ), + cancel: covered( + test( + "src/application/frida/FridaInstrumentationService.test.ts", + "cleans up a session and returns typed cancellation after a pending start", + ), + ), + cleanup: covered( + test( + "src/frida/FridaInstrumentationManager.test.ts", + "refuses new session work after incomplete close while retaining cleanup for retry", + ), + ), + retry: covered( + test( + "src/frida/FridaInstrumentationManager.test.ts", + "retains a failed script handle until a later cleanup retry releases it", + ), + ), + }, + }, + ghidra: { + ownership: "process", + stages: { + launch: covered( + test( + "src/ghidra/GhidraLaunchFailure.test.ts", + "retains the failed launcher command outcome on the launch error", + ), + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "cancels startup promptly and leaves no project or process", + ), + ), + handshake: covered( + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "completes an exact, fragmented post-analysis handshake", + ), + test( + "tests/boundary/mcp/ghidraReopen.test.ts", + "refuses an uncommitted handshake report before the first query and replaces that session on reopen", + ), + ), + operation: covered( + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "correlates an admitted inventory request after startup", + ), + ), + cancel: covered( + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "cancels queued work and stops active provider work on cancellation", + ), + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "retains the identity refusal when cancellation arrives during final startup cleanup", + ), + ), + cleanup: covered( + test( + "tests/boundary/mcp/ghidraReopen.test.ts", + "retains failed cleanup and refuses replacement until cleanup can be retried", + ), + ), + retry: covered( + test( + "src/ghidra/GhidraProvider.behavior.test.ts", + "reports rejection cleanup that failed and retries it on close", + ), + test( + "tests/boundary/providers/ghidra/ghidraClient.test.ts", + "redacts authentication after failed startup cleanup and retry", + ), + ), + }, + }, + "gnu.gdb": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/providers/GdbSessionManagerCoverage.test.ts", + "retains ownership when GDB startup fails before its prompt and stop is incomplete", + ), + ), + handshake: covered( + test( + "tests/boundary/providers/GdbSessionManagerCoverage.test.ts", + "returns startup timeout when the MI prompt never arrives", + ), + test( + "tests/boundary/providers/GdbSessionManagerCoverage.test.ts", + "retries MI2 after an MI3 process exits before its startup prompt", + ), + ), + operation: covered( + test( + "tests/boundary/providers/GdbSessionManagerCoverage.test.ts", + "correlates command output records and reports invalid or cancelled requests", + ), + ), + cancel: covered( + test( + "tests/boundary/mcp/gdbCancellationMcp.test.ts", + "propagates MCP cancellation into a running GDB command", + ), + ), + cleanup: covered( + test( + "tests/boundary/cli/gdbStartupCleanupCli.test.ts", + "marks the CLI failed when retained GDB cleanup remains incomplete", + ), + ), + retry: covered( + test( + "tests/boundary/cli/gdbStartupCleanupCli.test.ts", + "retries retained GDB cleanup when CLI session startup fails", + ), + test( + "tests/boundary/providers/GdbSessionManagerCoverage.test.ts", + "retains failed startup ownership when stop rejects and resolves it on retry", + ), + ), + }, + }, + "go-build-info": inProcess( + covered( + test( + "tests/acceptance/goBinaryCli.test.ts", + "delivers a Go CLI summary with its unchanged complete source bundle", + ), + ), + covered( + test( + "src/application/go/GoBinaryService.test.ts", + "honors cancellation before reading and after a completed observation", + ), + ), + ), + "gpu-code-objects": inProcess( + covered( + test( + "tests/boundary/gpu/codeObjects.test.ts", + "does not decode unselected payloads and keeps stable positional identities", + ), + ), + covered( + test( + "tests/process-global/gpuFileLifetime.test.ts", + "preserves completed observations when caller cancellation arrives during final close", + ), + ), + ), + "har-schema/lossless-json": historicalCapture( + covered( + test( + "tests/boundary/browser/historicalWebCapture.test.ts", + "preserves opaque HAR container fields through CLI and MCP", + ), + ), + ), + hopper: { + ownership: "process", + stages: { + launch: covered( + test( + "tests/acceptance/providers/hopperStartupRecovery.test.ts", + "recovers a denied Hopper launch through the same stdio MCP session and CLI", + ), + test( + "tests/boundary/providers/hopper/hopperClient.protocol.test.ts", + "records process exit code, stage, and restart guidance on unexpected exit", + ), + ), + handshake: covered( + test( + "tests/boundary/providers/hopper/hopperClient.health.test.ts", + "reports launch work until the first authenticated handshake completes", + ), + test( + "tests/boundary/providers/hopper/hopperClient.handshakeRecovery.test.ts", + "recovers an application exit after the first valid handshake occurs during cleanup", + ), + ), + operation: covered( + test( + "tests/boundary/providers/hopper/hopperClient.protocol.test.ts", + "does not start cold and preserves normal dispatch once ready", + ), + ), + cancel: covered( + test( + "tests/boundary/providers/hopper/hopperClient.progress.test.ts", + "cancels and ignores late responses without corrupting the session", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/hopper/hopperClient.cleanupRetry.test.ts", + "retains failed startup cleanup until an owned process and its backing image are closed", + ), + ), + retry: covered( + test( + "tests/boundary/providers/hopper/hopperClient.cleanupRetry.test.ts", + "retries a failed lease release after document, process, and runtime cleanup are confirmed", + ), + ), + }, + }, + ida: { + ownership: "process", + stages: { + launch: covered( + test( + "src/ida/IdaMcpEnvironment.test.ts", + "launches the owned stdio server with only the selected snapshot, never ambient variables", + ), + test( + "src/ida/IdaMcpWindowsLaunch.test.ts", + "refuses a network-share executable before launch with a drive-letter remedy", + ), + ), + handshake: covered( + test( + "src/ida/IdaMcpOwnedCleanup.test.ts", + "keeps a failed handshake's incomplete cleanup observable with the redacted server tail", + ), + ), + operation: covered( + test( + "src/ida/IdaNativeProtocol.test.ts", + "retains native tool provenance, reads recorded metadata, and closes only its connection", + ), + ), + cancel: covered( + test( + "src/ida/IdaSessionClient.test.ts", + "drains in-flight read-only work on cancellation before closing its proxy", + ), + ), + cleanup: covered( + test( + "src/ida/IdaSessionClient.test.ts", + "retains the private workspace and reports cleanup failure when worker release is unverified", + ), + ), + retry: covered( + test( + "src/ida/IdaSessionClient.test.ts", + "retries failed worker release through the retained connection before removing its workspace", + ), + ), + }, + }, + "il2cpp-metadata": inProcess( + covered( + test( + "tests/acceptance/il2cppMetadataCli.test.ts", + "queries compact retained metadata through the real SDK with exact row identities and fields", + ), + ), + covered( + test( + "tests/boundary/il2cpp/il2cppMetadataProvider.test.ts", + "accepts cancellation between binary linking batches and keeps the metadata source", + ), + ), + ), + jadx: { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/process/jadxStartup.test.ts", + "returns terminal startup diagnostics and partial identity through the MCP contract", + ), + ), + handshake: covered( + test( + "tests/boundary/process/jadxIntegration.test.ts", + "classifies a heap shortage that stops the bridge before the handshake", + ), + ), + operation: covered( + test( + "tests/boundary/process/jadxIntegration.test.ts", + "retires an idle engine and starts a fresh one for a later request", + ), + ), + cancel: covered( + test( + "tests/boundary/process/jadxIntegration.test.ts", + "cancels active and queued requests, cleans ownership and never launches a queued cancelled request", + ), + ), + cleanup: covered( + test( + "tests/boundary/process/jadxIntegration.test.ts", + "retains an uncertain workspace and blocks later launches after cleanup cannot be verified", + ), + ), + retry: covered( + test( + "tests/boundary/process/jadxStartup.test.ts", + "retains the startup primary across cleanup failure and retry", + ), + test( + "tests/boundary/android/jadxMcpTransport.test.ts", + "retries an incomplete owned stop while joining concurrent close callers", + ), + ), + }, + }, + jeb: { + ownership: "connection", + stages: { + launch: ATTACH_ONLY, + handshake: covered( + test( + "tests/boundary/providers/jebMcpCatalog.test.ts", + "reads every JEB catalog page and refreshes the connected engine catalog", + ), + test( + "tests/boundary/providers/jebMcpConnection.test.ts", + "reconnects after a catalog refresh loses its session without replaying the refresh", + ), + ), + operation: covered( + test( + "tests/boundary/providers/jebMcpReplies.test.ts", + "retains own structured fields through the JEB SDK transport", + ), + ), + cancel: covered( + test( + "src/jeb/JebProvider.test.ts", + "forwards in-flight cancellation to the MCP call", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/jebMcpConnection.test.ts", + "retains failed cleanup ownership and does not reuse the invalid session before cleanup succeeds", + ), + ), + retry: covered( + test( + "tests/boundary/providers/jebMcpConnection.test.ts", + "retains the typed timeout when disposal fails and retries owned cleanup before reconnecting", + ), + ), + }, + }, + kuna: { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/providers/kuna/kunaSelectedCommand.test.ts", + "uses the selected Kuna launcher and its sibling producer for readiness and commands", + ), + test( + "tests/boundary/providers/kuna/kunaProvider.test.ts", + "refuses to launch an executable replaced after the target was opened", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/providers/kuna/kunaIndependentDecompileMcp.test.ts", + "runs a cold independent request without starting a project export", + ), + ), + cancel: covered( + test( + "tests/boundary/providers/kuna/kunaCommandCancellation.test.ts", + "keeps cancellation output and primary reason while exact command cleanup is retried", + ), + test( + "tests/boundary/providers/kuna/kunaProvider.test.ts", + "stops waiting for the export when the caller cancels, without abandoning it", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/kuna/kunaPublicationCleanup.test.ts", + "preserves the original failed export when staging cleanup also fails", + ), + test( + "tests/boundary/providers/kuna/kunaProjectCache.test.ts", + "keeps staging owned when a cancelled Kuna process cannot be proven stopped", + ), + ), + retry: covered( + test( + "tests/boundary/providers/kuna/kunaProvider.test.ts", + "keeps reporting a failed close and succeeds once a retry proves the stop", + ), + ), + }, + }, + "mitmproxy-native-tnetstring": historicalCapture( + gap( + "The decoder tests bind mitmproxy configuration but no regression completes a mitmproxy capture.", + ), + ), + "model-artifact": inProcess( + covered( + test( + "tests/acceptance/modelArtifactCli.test.ts", + "bounds compact model warnings and omits unselected long labels while retaining complete Evidence", + ), + ), + covered( + test( + "tests/boundary/model/modelArtifactPartialCancellation.test.ts", + "retains GGUF tensor declarations and layout limitations before later tensor bytes cancel", + ), + ), + ), + "native-macos": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/providers/native/lldbCallTracerFailures.test.ts", + "releases a launch failure after the bridge proves the process exited", + ), + ), + handshake: covered( + test( + "tests/boundary/providers/native/lldbLauncherBoundary.test.ts", + "reports why the host could not establish the launched target's identity", + ), + ), + operation: covered( + test( + "tests/boundary/providers/native/nativeCallObservation.test.ts", + "launches the active Mach-O through the tracer and projects its run", + ), + ), + cancel: covered( + test( + "tests/boundary/providers/native/lldbCallTracerFailures.test.ts", + "preserves cancellation and journal/output evidence after runtime cleanup", + ), + test( + "tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts", + "does not retain a target when cancellation proves LLDB never launched", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts", + "retains an unidentified debuggee and runtime until exit can be confirmed", + ), + ), + retry: covered( + test( + "tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts", + "retains a real LLDB process owner and runtime until a later cleanup retry succeeds", + ), + test( + "tests/boundary/providers/native/nativeCommandTermination.test.ts", + "retains and retries every failed native command cleanup owner before launching another command", + ), + ), + }, + }, + "objdump.command": { + ownership: "process", + stages: { + launch: covered( + test( + REVERSE_LAUNCH_ERRORS, + "preserves Darwin process ownership inspection preparation error without blaming objdump command", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/composition/objdumpSelectedDisassembly.test.ts", + "keeps omitted and undefined selection out of default command Evidence", + ), + ), + cancel: covered( + test( + "tests/composition/reverseEngineeringAdmission.test.ts", + "preserves the caller reason when cancellation arrives after provider output", + ), + ), + cleanup: covered( + test( + REVERSE_EDGE_CASES, + "retains an objdump command's unverified process owner until a later inspection stops it", + ), + ), + retry: covered( + test( + REVERSE_EDGE_CASES, + "retains an objdump command's unverified process owner until a later inspection stops it", + ), + ), + }, + }, + pcap: { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/pcap/pcapCommand.test.ts", + "attributes a refused limiter spawn to the limiter, not Wireshark", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/pcap/pcapProvider.test.ts", + "inspects a capture with endpoints, DNS, TLS SNI, and HTTP", + ), + ), + cancel: covered( + test( + "tests/boundary/pcap/pcapCommand.test.ts", + "preserves a failed producer when cancellation arrives during its final cleanup", + ), + ), + cleanup: covered( + test( + "tests/boundary/pcap/pcapCommand.test.ts", + "returns complete stdout while retaining unresolved process cleanup", + ), + ), + retry: covered( + test( + "tests/boundary/pcap/pcapCredentialErrors.test.ts", + "retains safe cleanup observations and retries their original owner", + ), + ), + }, + }, + "pwntools-elf": { + ownership: "process", + stages: { + launch: covered( + test( + "src/native/pwntools/PwntoolsFailures.test.ts", + "does not read an errno from another syscall as a launch refusal", + ), + ), + handshake: covered( + test( + "tests/process-global/pwntoolsCliFinalization.test.ts", + "preserves cancellation across a late owned process handshake", + ), + ), + operation: covered( + test( + "tests/process-global/pwntoolsCliFinalization.test.ts", + "recovers a completed worker reply after terminal process cleanup succeeds", + ), + ), + cancel: covered( + test( + "tests/process-global/pwntoolsCleanup.test.ts", + "cancels queued inspections promptly and drains the running inspection when closing", + ), + ), + cleanup: covered( + test( + "tests/process-global/pwntoolsCliFinalization.test.ts", + "preserves the validated report when runtime removal remains denied", + ), + ), + retry: covered( + test( + "tests/process-global/pwntoolsCleanup.test.ts", + "retains a failed root removal and retries it before acquiring another decoder", + ), + ), + }, + }, + "rea-analysis-view": inProcess( + covered( + test( + "tests/acceptance/applications/progressiveAnalysisViews.test.ts", + "loads retained analysis views only when needed, preserving complete schemas, source facts and Evidence", + ), + ), + covered( + test( + "src/application/analysisView/AnalysisViewService.test.ts", + "returns typed cancellation when a running file request is aborted", + ), + ), + ), + "rea-android-application": inProcess( + covered( + test( + "tests/boundary/mcp/androidPackageSummaryMcp.test.ts", + "retains complete APK Evidence and reads exact manifest without its source or another engine launch", + ), + ), + covered( + test( + "tests/boundary/mcp/androidPackageSummaryMcp.test.ts", + "rejects unavailable retention, invalid selectors and cancellation before provider execution", + ), + ), + ), + "rea-apple-application": { + ownership: "process", + stages: { + launch: gap( + "No regression for an assetutil or Interface Builder tool launch failure.", + ), + handshake: ONE_SHOT, + operation: covered( + test( + "src/artifacts/apple/AppleAssetCatalogAnalysis.test.ts", + "joins only explicit resource-key fields with archive provenance", + ), + ), + cancel: covered( + test( + "src/artifacts/apple/AppleAssetCatalogAnalysis.test.ts", + "settles a cancelled assetutil run only after its process exits", + ), + ), + cleanup: gap("No regression for failed assetutil process cleanup."), + retry: gap("No regression for assetutil cleanup retry."), + }, + }, + "rea-apple-ips": inProcess( + covered( + test( + "tests/boundary/filesystem/appleIpsJoin.test.ts", + "joins matching UUID and architecture and derives static addresses", + ), + ), + covered( + test( + "src/native/apple/AppleIpsProvider.test.ts", + "retains completed join facts when cancellation arrives during join parsing", + ), + ), + ), + "rea-artifact-graph": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/providers/native/nativeDmgArtifactReader.test.ts", + "distinguishes child launch and host permission failures", + ), + ), + handshake: notApplicable( + "DMG attach and detach are one-shot hdiutil commands; other formats are read in-process.", + ), + operation: covered( + test( + "tests/boundary/providers/native/nativeDmgArtifactReader.test.ts", + "uses plist attachment metadata and detaches returned devices", + ), + ), + cancel: covered( + test( + "tests/boundary/providers/native/artifactProvider.zipCancellation.test.ts", + "preserves a real ZIP stream's caller cancellation through extraction rollback", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/native/nativeDmgArtifactReader.test.ts", + "retains the root and reports unknown ownership when recovery discovery fails", + ), + ), + retry: covered( + test( + "tests/boundary/providers/native/nativeDmgArtifactReader.test.ts", + "retains a mounted directory after its close fails and retries before detach", + ), + test( + "tests/boundary/providers/native/artifactProvider.cleanupRetry.test.ts", + "retains a failed reader close, blocks new work, and retries the same reader", + ), + ), + }, + }, + "rea-binary-hardening": inProcess( + covered( + test( + "tests/acceptance/binaryHardeningCli.test.ts", + "reads ELF and PE hardening through the CLI and MCP", + ), + ), + covered( + test( + "tests/boundary/filesystem/binaryHardening.test.ts", + "returns typed resource and cancellation failures and leaves bytes unchanged", + ), + ), + ), + "rea-cdp-browser": { + ownership: "connection", + stages: { + launch: ATTACH_ONLY, + handshake: covered( + test( + CDP_BROWSER_SOCKET, + "times out a WebSocket handshake that never completes", + ), + test( + CDP_BROWSER_SOCKET, + "coalesces concurrent cold-start calls onto one browser WebSocket handshake", + ), + ), + operation: covered( + test( + CDP_BROWSER_SOCKET, + "reuses one admitted browser socket across sequential operations and closes on provider shutdown", + ), + ), + cancel: covered( + test( + "tests/boundary/browser/cdpBrowserProvider.lifecycle_failures.test.ts", + "cancels observation and still detaches without closing the page", + ), + test( + CDP_CLEANUP_CANCELLATION, + "releases cleanup when cancellation arrives after capture completes", + ), + ), + cleanup: covered( + test( + CDP_BROWSER_SOCKET, + "surfaces cleanupIncomplete when forced shared-socket close fails after detach rejection", + ), + ), + retry: covered( + test( + CDP_BROWSER_SOCKET, + "records cleanup lease ownership when finish() callback rejects and resolves on retryPending", + ), + test( + CDP_BROWSER_SOCKET, + "blocks new admissions while forced shared-socket cleanup fails with an active peer, then recovers cleanly", + ), + ), + }, + }, + "rea-cdp-electron": { + ownership: "connection", + stages: { + launch: ATTACH_ONLY, + handshake: gap( + "No Electron-provider regression for a late, absent or failed CDP handshake.", + ), + operation: covered( + test( + "tests/boundary/browser/cdpElectronProvider.test.ts", + "returns every Electron page target exposed by the endpoint inline", + ), + ), + cancel: covered( + test( + "tests/boundary/browser/cdpElectronProvider.test.ts", + "retains a completed page observation when cancellation arrives during final detach", + ), + test( + CDP_CLEANUP_CANCELLATION, + "classifies cancellation that arrives during final Electron detach", + ), + ), + cleanup: gap( + "No regression retains a failed Electron inspection cleanup; the cleanup tests cover cancellation during a successful close.", + ), + retry: gap("No regression for Electron inspection cleanup retry."), + }, + }, + "rea-devicetree": inProcess( + covered( + test( + "tests/acceptance/devicetreeCli.test.ts", + "rejects ambiguous Devicetree node paths in correctly hashed Evidence", + ), + ), + covered( + test( + "src/application/binaryDiagnostics/DevicetreeService.test.ts", + "retains a completed observation when the caller cancels as the provider completes", + ), + ), + ), + "rea-dotnet-static": inProcess( + covered( + test( + "tests/acceptance/dotnetBundleJourney.test.ts", + "inspects and extracts ${format} through public CLI and stdio MCP", + ), + ), + covered( + test( + "tests/boundary/providers/managed/managedStaticProvider.test.ts", + "preserves cancellation when snapshot cleanup also fails", + ), + ), + ), + "rea-dotnet-workflows": inProcess( + covered( + test( + "tests/boundary/mcp/managedWorkflowUnknownIdentityMcp.test.ts", + "retains partial native export coverage after an observed match", + ), + ), + gap("No cancellation regression for the managed workflow provider."), + ), + "rea-elf-notes": inProcess( + covered( + test( + "tests/acceptance/elfNotesCli.test.ts", + "resolves section note names from zlib and Zstandard string tables through the CLI", + ), + ), + typedFailures("tests/boundary/filesystem/elfNotes.test.ts"), + ), + "rea-elf-unwind-ranges": inProcess( + covered( + test( + "tests/boundary/filesystem/elfUnwindRanges.test.ts", + "accepts a header whose search table is omitted, as GNU ld writes it", + ), + ), + typedFailures("tests/boundary/filesystem/elfUnwindRanges.test.ts"), + ), + "rea-erlang-beam": inProcess( + covered( + test( + "tests/acceptance/erlangBeamCli.test.ts", + "reports BEAM tables and code through the public CLI", + ), + ), + typedFailures("tests/boundary/filesystem/erlangBeam.test.ts"), + ), + "rea-harmony-application": inProcess( + covered( + test( + "tests/acceptance/harmonyArtifactJourney.test.ts", + "preserves Harmony archive formats through the public CLI/MCP lifecycle", + ), + ), + gap("No cancellation regression for the Harmony application provider."), + ), + "rea-javascript-application": { + ownership: "process", + stages: { + launch: gap( + "No regression for a JavaScript analysis worker process that fails to launch.", + ), + handshake: gap( + "No regression for a late or invalid worker admission frame from the provider side.", + ), + operation: covered( + test( + "tests/acceptance/javascriptRoutesCli.test.ts", + "keeps a large source's partial route facts queryable through SDK delivery", + ), + ), + cancel: covered( + test( + "tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.ts", + "keeps unselected files outside scope when the real worker cancels after the last selected file", + ), + ), + cleanup: covered( + test( + "src/javascript/analysis/JavaScriptAnalysisWorker.inspection.test.ts", + "retains a mixed identity batch's actual descriptor until the same owner retries", + ), + ), + retry: covered( + test( + "src/javascript/analysis/JavaScriptAnalysisWorker.inspection.test.ts", + "retries the exact failed inspection owner before releasing its error", + ), + ), + }, + }, + "rea-javascript-application-workflows": inProcess( + covered( + test( + "tests/boundary/filesystem/javascriptApplicationWorkflows.test.ts", + "traces a contextBridge API through IPC into linked native evidence", + ), + ), + gap("No cancellation regression for JavaScript application workflows."), + ), + "rea-javascript-runtime-reconciliation": inProcess( + covered( + test( + "tests/boundary/filesystem/javascript-applications/javascriptRuntimeReconciliation.test.ts", + "matches renderer, frame, script bytes, and worker without claiming execution", + ), + ), + gap("No cancellation regression for JavaScript runtime reconciliation."), + ), + "rea-kernel-build-config": inProcess( + covered( + test( + "tests/boundary/filesystem/kernelBuildConfig.test.ts", + "reports an ordinary IKCFG_ST string as no config with file Evidence", + ), + ), + covered( + test( + "src/native/elf/KernelBuildConfig.test.ts", + "honors an abort raised while the parse is running", + ), + ), + ), + "rea-kernel-module": inProcess( + covered( + test( + "tests/acceptance/kernelModuleCli.test.ts", + "reports license, duplicate aliases, and version CRCs through the public CLI", + ), + ), + typedFailures("tests/boundary/filesystem/kernelModule.test.ts"), + ), + "rea-native-exports": inProcess( + covered( + test( + "tests/boundary/filesystem/nativeExports.test.ts", + "binds PE and ELF export inventories to the selected file", + ), + ), + covered( + test( + "tests/boundary/filesystem/nativeExports.test.ts", + "returns typed input, unsupported, budget and cancellation failures", + ), + ), + ), + "rea-native-initializers": inProcess( + covered( + test( + "tests/acceptance/nativeInitializersCli.test.ts", + "lists Mach-O initializers and finalizers through the public CLI", + ), + ), + covered( + test( + "src/native/initializers/NativeInitializersParsers.test.ts", + "observes cancellation during the section relocation walk", + ), + ), + ), + "rea-pe-certificates": inProcess( + gap( + "Successful certificate tables are covered at the parser and through generated CLI titles, not by a literal-titled provider regression.", + ), + typedFailures("tests/boundary/filesystem/peCertificates.test.ts"), + ), + "rea-pe-imports": inProcess( + covered( + test( + "tests/boundary/filesystem/peImports.test.ts", + "retains partial Evidence for an import name beyond the read allowance", + ), + ), + typedFailures("tests/boundary/filesystem/peImports.test.ts"), + ), + "rea-pe-load-config": inProcess( + covered( + test( + "tests/boundary/filesystem/peLoadConfig.test.ts", + "retains completed PE acquisition through %s", + ), + ), + typedFailures("tests/boundary/filesystem/peLoadConfig.test.ts"), + ), + "rea-pe-resources": inProcess( + covered( + test( + "tests/boundary/filesystem/peResources.test.ts", + "admits the largest measured stock Windows resource table by default", + ), + ), + typedFailures("tests/boundary/filesystem/peResources.test.ts"), + ), + "rea-playwright-browser-scenario": { + ownership: "process", + stages: { + launch: covered( + test( + "src/browser/PlaywrightScenarioBrowser.test.ts", + "normalizes a genuine Playwright launch timeout and releases its profile", + ), + test( + "src/browser/PlaywrightScenarioBrowser.test.ts", + "passes the selected environment to the actual browser launch boundary", + ), + ), + handshake: covered( + test( + "src/browser/PlaywrightScenarioBrowser.test.ts", + "applies command_timeout_ms to the primary connect handshake when service workers are allowed", + ), + test( + "src/browser/PlaywrightScenarioBrowser.test.ts", + "closes a browser that connects after its deadline without waiting to report the timeout", + ), + ), + operation: covered( + test( + "src/browser/PlaywrightBrowserScenarioProvider.test.ts", + "returns an initial state and every step beyond the former action ceiling", + ), + ), + cancel: covered( + test( + "src/browser/PlaywrightBrowserScenarioProvider.test.ts", + "cancels an active action and still closes the session", + ), + ), + cleanup: covered( + test( + "src/browser/PlaywrightBrowserScenarioProvider.test.ts", + "returns a cleanup failure with completed observations when close fails", + ), + ), + retry: covered( + test( + "src/browser/PlaywrightBrowserScenarioProvider.test.ts", + "shares concurrent close and retries browser cleanup after failure", + ), + ), + }, + }, + "rea-playwright-electron-active": { + ownership: "process", + stages: { + launch: covered( + test( + "src/browser/PlaywrightElectronActiveProvider.test.ts", + "passes the selected environment and ownership token to Electron launch", + ), + ), + handshake: covered( + test( + "src/browser/PlaywrightElectronActiveProvider.test.ts", + "joins a late launch acknowledgement and its cleanup after shutdown", + ), + ), + operation: covered( + test( + "src/browser/PlaywrightElectronActiveActions.test.ts", + "runs an untargeted deep-link without requiring a BrowserWindow", + ), + ), + cancel: covered( + test( + "src/browser/PlaywrightElectronActiveProvider.test.ts", + "cancels a windowless wait action and cleans up the owned application", + ), + ), + cleanup: covered( + test( + "src/browser/PlaywrightElectronActiveProvider.test.ts", + "keeps cleanup failure precedence over cancellation observed during cleanup", + ), + ), + retry: covered( + test( + "src/browser/PlaywrightElectronActiveProvider.test.ts", + "retains failed ownership-helper cleanup until provider close retries it", + ), + ), + }, + }, + "rea-python-pyc": inProcess( + covered( + test( + "tests/boundary/mcp/pythonPycMcp.test.ts", + "reads signed TYPE_INT64 constants and rejects a truncated payload", + ), + ), + typedFailures("tests/boundary/filesystem/pythonPyc.test.ts"), + ), + "rea-release-exposure": inProcess( + covered( + test( + "tests/boundary/filesystem/releaseExposure.test.ts", + "audits an ASAR whose unpacked module was signed after packaging", + ), + ), + typedFailures("tests/boundary/filesystem/releaseExposure.test.ts"), + ), + "rea-v8-code-cache": inProcess( + covered( + test( + "tests/acceptance/v8CodeCacheCli.test.ts", + "reports the observed header and payload through the public CLI", + ), + ), + gap("No cancellation regression for the V8 code cache provider."), + ), + "rea-v8-inspector": { + ownership: "connection", + stages: { + launch: ATTACH_ONLY, + handshake: gap( + "No regression for a late, absent or failed inspector WebSocket handshake.", + ), + operation: covered( + test( + "tests/acceptance/tools/inspectorLifecycle.test.ts", + "observes a real Node Inspector and releases attachments after cancellation and failures", + ), + ), + cancel: covered( + test( + "src/inspector/V8InspectorCaptureProjection.test.ts", + "stops finalization when cancellation arrives during location authorization", + ), + ), + cleanup: covered( + test( + "src/inspector/V8InspectorProvider.closeOwnership.test.ts", + "retains cancelled final-close ownership and retries the exact transport before replacement observation", + ), + ), + retry: covered( + test( + "src/inspector/V8InspectorProvider.closeOwnership.test.ts", + "retains cancelled final-close ownership and retries the exact transport before replacement observation", + ), + ), + }, + }, + "rea-web-module-trace": { + ownership: "process", + stages: { + launch: covered( + test( + "src/browser/modules/NativeModuleResolver.test.ts", + "retains the selected executable and actual startup diagnostic", + ), + ), + handshake: gap( + "No regression for a late or failed browser-engine connection after Chromium launches.", + ), + operation: covered( + test( + "tests/boundary/filesystem/webModuleArtifacts.test.ts", + "verifies original bytes and tolerates relocation without inventing URL paths", + ), + ), + cancel: covered( + test( + "src/browser/modules/NativeModuleResolver.test.ts", + "does not acquire a browser after caller cancellation", + ), + test( + "src/application/WebModuleTraceService.test.ts", + "does not start the native resolver after cancellation during artifact admission", + ), + ), + cleanup: covered( + test( + "src/browser/modules/NativeModuleResolver.test.ts", + "returns cleanup_incomplete when owned cleanup fails after an engine error", + ), + ), + retry: gap( + "The resolver retries retained browser cleanup before later work, but no regression names that retry.", + ), + }, + }, + "rea-web-script-export": inProcess( + covered( + test( + "tests/boundary/filesystem/javascriptExportShapeComparison.test.ts", + "preserves accessor-effect uncertainty through analyzed Evidence and export comparison", + ), + ), + covered( + test( + "tests/boundary/filesystem/webScriptExport.test.ts", + "cancels before work and rolls back cancellation after output creation", + ), + ), + ), + "rea-web-source-location": { + ownership: "process", + stages: { + launch: covered( + test( + SOURCE_MAP_DECODER_BOUNDARY, + "removes the private request when launching the codec fails", + ), + ), + handshake: notApplicable( + "The source-map codec child writes one reply per request; there is no handshake.", + ), + operation: covered( + test( + "tests/boundary/filesystem/webSourceLocationArtifacts.test.ts", + "reads exact selected map bytes, retaining a BOM and explicitly selected URL context", + ), + ), + cancel: covered( + test( + SOURCE_MAP_DECODER_BOUNDARY, + "cancels a real owned process and removes the runtime request", + ), + test( + "src/application/WebSourceLocationService.test.ts", + "honors cancellation both before acquisition and across decoder completion", + ), + ), + cleanup: covered( + test( + "src/javascript/sourceMaps/SourceMapDecoder.test.ts", + "settles every source-map cleanup failure when final close releases the exact runtime", + ), + ), + retry: covered( + test( + "src/javascript/sourceMaps/SourceMapDecoder.test.ts", + "retains physical failure and late cancellation through cleanup failure and retry", + ), + ), + }, + }, + "rea-windows-shortcut": inProcess( + covered( + test( + "tests/acceptance/windowsShortcutCli.test.ts", + "reports Shell Link facts through CLI and stdio MCP", + ), + ), + typedFailures("tests/boundary/filesystem/windowsShortcut.test.ts"), + ), + rizin: { + ownership: "process", + stages: { + launch: covered( + test( + REVERSE_LAUNCH_ERRORS, + "preserves provider-launch ENOENT for a real execute_rizin_command target and records launch failure", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/composition/reverseEngineering.test.ts", + "passes decoder and map inputs to Rizin before the path and records them", + ), + ), + cancel: covered( + test( + "tests/composition/reverseEngineeringCancellation.test.ts", + "waits for a cancelled Rizin process to exit before returning", + ), + ), + cleanup: covered( + test( + REVERSE_EDGE_CASES, + "retains a capability failure when its injected owned runner also reports incomplete cleanup", + ), + ), + retry: covered( + test( + REVERSE_EDGE_CASES, + "releases a retained provider owner after cleanup succeeds", + ), + ), + }, + }, + "rizin.debugger": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/providers/RizinDebugSessionCoverage.part2.test.ts", + "maps injected spawn errors and startup protocol failure", + ), + ), + handshake: covered( + test( + "tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts", + "times out startup through the frame wait when Rizin never emits a frame", + ), + test( + "tests/boundary/providers/RizinDebugSessionReviewRegressions.test.ts", + "rejects startup when Rizin exits immediately after its initial frame", + ), + ), + operation: covered( + test( + "tests/boundary/providers/RizinDebugSessionCoverage.part3.test.ts", + "correlates an injected command frame with its generated marker", + ), + ), + cancel: covered( + test( + "tests/boundary/mcp/rizinDebuggerCancellationMcp.test.ts", + "propagates MCP cancellation into a running Rizin debugger command", + ), + ), + cleanup: covered( + test( + "tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts", + "retains owned fixture processes and files until a failed cleanup can complete", + ), + ), + retry: covered( + test( + "tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts", + "retains close failures and resolves their owner after cleanup retry", + ), + ), + }, + }, + "rust-auditable": inProcess( + covered( + test( + "tests/boundary/rust/rustBinaryBudget.test.ts", + "recovers the same complete Rust image after input and report budget changes", + ), + ), + covered( + test( + "src/application/rust/RustBinaryService.test.ts", + "retains completed Rust Evidence on late cancellation and keeps output failure precedence", + ), + ), + ), + "sigrok-recording": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/signals/resourceLimits.test.ts", + "preserves lower inherited file/CPU limits in the real launch", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/signals/recordingProvider.test.ts", + "decodes an immutable copy, preserves options and warnings, and releases its directory", + ), + ), + cancel: covered( + test( + "tests/boundary/signals/recordingProvider.test.ts", + "retains a completed observation when cancellation arrives at the service boundary", + ), + ), + cleanup: covered( + test( + "tests/boundary/signals/recordingProvider.test.ts", + "retains a completed observation and cleanup ownership for retry", + ), + ), + retry: covered( + test( + "tests/boundary/signals/recordingProvider.test.ts", + "releases a retained decoder process cleanup before the next decode completes", + ), + ), + }, + }, + sqlite: { + ownership: "process", + stages: { + launch: gap( + "No regression for a SQLite worker process that fails to launch.", + ), + handshake: notApplicable( + "The SQLite worker writes one reply per request; there is no handshake.", + ), + operation: covered( + test( + "tests/boundary/sqlite/sqliteDatabaseProvider.test.ts", + "enforces a selected worker budget and completes the corrected same-database retry", + ), + ), + cancel: covered( + test( + "tests/boundary/sqlite/sqliteDatabaseDescriptorCleanup.test.ts", + "retains cancellation diagnostics and the interrupt exit code through CLI shutdown", + ), + ), + cleanup: covered( + test( + "tests/boundary/sqlite/sqliteDatabaseCleanup.test.ts", + "retains the snapshot until a failed worker cleanup owner can be stopped", + ), + ), + retry: covered( + test( + "tests/boundary/sqlite/sqliteDatabaseCleanup.test.ts", + "retains failed snapshot owners and blocks new acquisition until retry succeeds", + ), + ), + }, + }, + "tshark-capture": { + ownership: "process", + stages: { + launch: covered( + test( + "tests/boundary/captures/resourceLimits.test.ts", + "preserves lower inherited file/CPU limits in the real launch", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/captures/captureProvider.test.ts", + "returns canonical alias output through the public packet-capture CLI", + ), + ), + cancel: covered( + test( + "tests/boundary/captures/captureProvider.test.ts", + "retains a completed observation when cancellation arrives at the service boundary", + ), + ), + cleanup: covered( + test( + "tests/boundary/captures/captureProvider.test.ts", + "retains a completed observation and cleanup ownership for retry", + ), + ), + retry: covered( + test( + "tests/boundary/captures/captureProvider.test.ts", + "releases a retained decoder process cleanup before the next inspection completes", + ), + ), + }, + }, + unblob: { + ownership: "process", + stages: { + launch: covered( + test( + FIRMWARE_INTEGRATION, + "retains startup stderr when Unblob exits 1 without a report", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + FIRMWARE_INTEGRATION, + "extracts a selected interval with verified file identity and parent-byte lineage", + ), + ), + cancel: covered( + test( + "tests/process-global/firmwareFileLifetime.test.ts", + "preserves primitive cancellation before publication commit and rolls back the output", + ), + ), + cleanup: covered( + test( + FIRMWARE_INTEGRATION, + "retains the complete firmware result when published output cleanup stays uncertain", + ), + ), + retry: covered( + test( + FIRMWARE_INTEGRATION, + "retains a setup-failed publication tree for provider cleanup retry", + ), + ), + }, + }, + "wabt-artifact": { + ownership: "process", + stages: { + launch: covered( + test( + "src/wasm/WabtFailures.test.ts", + "reports a WABT tool the host refused to start as unavailable", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "src/wasm/WabtArtifactProvider.test.ts", + "admits a compatible caller WABT release and records the observed banner", + ), + ), + cancel: covered( + test( + "src/wasm/WabtArtifactProvider.test.ts", + "reports a snapshot write the caller cancelled as that caller's cancellation", + ), + ), + cleanup: covered( + test( + "src/wasm/WabtArtifactProvider.test.ts", + "bounds the excerpt when cleanup also fails after the output budget", + ), + ), + retry: covered( + test( + "src/wasm/WabtArtifactProvider.test.ts", + "retries a retained input descriptor before admitting the next WABT operation", + ), + ), + }, + }, + wakaru: { + ownership: "process", + stages: { + launch: covered( + test( + "src/javascript/recovery/WakaruCommand.test.ts", + "preserves a real launch failure when the caller cancels after it", + ), + ), + handshake: ONE_SHOT, + operation: covered( + test( + "tests/boundary/javascript-recovery/wakaruIntegration.test.ts", + "preserves selected source identities and layout through a symlink followed by ..", + ), + ), + cancel: covered( + test( + "tests/boundary/javascript-recovery/wakaruIntegration.test.ts", + "cancels an active recovery and verifies owned cleanup", + ), + ), + cleanup: covered( + test( + "tests/boundary/javascript-recovery/wakaruIntegration.test.ts", + "reports cleanup failure and retains the workspace named by the error", + ), + ), + retry: covered( + test( + "tests/boundary/javascript-recovery/wakaruIntegration.test.ts", + "retains a setup-failed publication tree for provider cleanup retry", + ), + ), + }, + }, +}; + +/** + * Every stage marked as a gap above, as `providerId:stage`. This list may only + * shrink: close a gap by naming its regression tests and removing the entry. + */ +export const PROVIDER_LIFECYCLE_GAPS: readonly string[] = [ + "aioquic-qlog-json:operation", + "mitmproxy-native-tnetstring:operation", + "rea-apple-application:cleanup", + "rea-apple-application:launch", + "rea-apple-application:retry", + "rea-cdp-electron:cleanup", + "rea-cdp-electron:handshake", + "rea-cdp-electron:retry", + "rea-dotnet-workflows:cancel", + "rea-harmony-application:cancel", + "rea-javascript-application-workflows:cancel", + "rea-javascript-application:handshake", + "rea-javascript-application:launch", + "rea-javascript-runtime-reconciliation:cancel", + "rea-pe-certificates:operation", + "rea-v8-code-cache:cancel", + "rea-v8-inspector:handshake", + "rea-web-module-trace:handshake", + "rea-web-module-trace:retry", + "sqlite:launch", +];