mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
* fix(pcap): report a refused tool launch as an unavailable tool When a capture read's tool launch was refused with EPERM, pcap reported it as unreadable tool output (AnalysisProtocolError) instead of an unavailable tool. Pcap also never told "not executable" apart from "missing". Add classifyLaunchFailure in src/process as the one owner of which spawn errnos mean missing (ENOENT, ENOTDIR) and which mean present but not executable (EACCES, EPERM, ENOEXEC, EISDIR). Pcap, apktool and gdb used three different errno lists; all three now use it. * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * refactor(process): classify Java and adb launch refusals with the shared owner (#10598) The Ghidra and JADX Java probes and adb's version probe now take missing-versus-not-executable from classifyLaunchFailure instead of their own errno checks. ELOOP and ENAMETOOLONG join the owner's missing set, so adb keeps its existing classification and both Java probes now treat a non-directory path component as a missing runtime. * fix(pcap): preserve command launch attribution * test(pcap): expect an unknown failing stage when a limited capture tool exits unsuccessfully * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * test(lint): cover baselined files in the provider-failure classifier rule * fix(apktool): report the decoder JVM's heap exhaustion as memory, not a target refusal The supervisor now watches for a managed runtime's out-of-memory report while output streams (JVM java.lang.OutOfMemoryError, V8 'JavaScript heap out of memory'), so a retention budget cannot hide it. ProviderOutcome gains a runtime-exhausted kind and classifyProviderOutcome maps it once. Apktool decode opts in and moves to the shared classifier; Ghidra's single-purpose output token becomes the JVM runtime option and its area matching reuses the shared table. * fix(process): keep the runtime's out-of-memory report on the memory error it supports * fix(pcap): attribute a limited capture's exit through the prlimit wrapper * fix(process): keep a shortened out-of-memory line marked as shortened * fix(process): identify the refused executable for every launcher shape Name the executable on errnos Node throws synchronously from spawn (ENOEXEC, ENOTDIR, ...) and read the Windows native launcher's executable-launch constraint, so pcap attributes those refusals to the selected tool or limiter instead of an unknown stage. * test(pcap): prove synchronous launch naming with ENOTDIR on every POSIX host * fix(apktool): advise the JVM limit that governs the reported memory area * fix(ghidra): read the supervisor's parsed OOM area instead of reparsing lines * fix(sqlite,capture): read V8 heap exhaustion from streamed output, not retained stderr (#10724) The SQLite worker and the Node capture decoders now declare runtime: "v8", so the supervisor observes V8's heap report as output streams. Both classifiers read the runtime-exhausted outcome instead of matching retained stderr, so a report beyond the retention budget, or one whose process then overflowed its output budget, is still reported as memory exhaustion. * refactor(evm): classify EVMole worker outcomes through the shared provider classifier (#10716) * refactor(evm): classify EVMole worker outcomes through the shared provider classifier The EVMole worker's cancellation, deadline, output budget and CPU/file-size signals now go through classifyProviderOutcome; only the prlimit launch refusal and the reserved EFBIG exit remain in its dialect. The worker is opted into V8 exhaustion scanning so a heap report names its fixed 256 MiB heap. providerOutcomeOf now reads a launch refusal only from a spawn errno, so a private-storage or carrier read errno is no longer reported as a limiter launch failure. * fix(evm): keep a stream failure's exit status and update Linux worker expectations * refactor(process): read launch refusals through the launcher identity owner * refactor(wasm): classify WABT command outcomes through the shared provider classifier (#10727) * refactor(wasm): classify WABT command outcomes through the shared provider classifier WABT's cancellation, command deadline, output budget, and inherited-limit signals now go through classifyProviderOutcome; its dialect keeps only the configuration-probe and launch-refusal unavailability and the unclassified-exit output error. A tool ended by SIGXCPU/SIGXFSZ or the memory limit is now a resource constraint instead of an output error, and a refused launch in the producer phase is reported as unavailable. The shared timeout context gains the analysis setting that selected the deadline, and the output-limit context may name its exceeded budget. * fix(wasm): keep setup guidance when a WABT version probe's output cannot be collected * refactor(providers): classify raw provider failures through one owner * refactor(process): build classified cancellations with cancelledBy and the carried caller reason * chore(lint): count runOwned's close-failure mapper from main in the classifier baseline * fix(process): carry the runtime's exhaustion report on every memory error that claims it SQLite and historical-capture memory errors recognised a streamed V8 heap report but dropped it, so a report outside retained output reached callers without its source line or omission flags. One projection, runtimeExhaustionReport, now owns that shape for the shared classifier and both consumers. Also lowers the EVMole and WABT cancellation-constructor baselines. * fix(process): keep the provider's recovery for a native-thread exhaustion report The shared classifier replaced the provider-supplied recovery with generic capacity advice whenever the JVM reported it could not create a native thread, dropping Apktool's launcher guidance and flipping retryable to true. The provider's recovery now wins; the capacity advice remains the fallback for providers that supply none. * refactor(pwntools): classify pwntools failures through the shared provider classifier (#10782) * refactor(pwntools): classify pwntools failures through the shared provider classifier pwntools' per-site classifier is replaced by pwntoolsFailureDialect for classifyProviderFailure. Command outcomes go through classifyProviderOutcome, launch refusals through launcherRefusalOf instead of a 'spawn ' syscall prefix check, the input limit through the file dialect's fileSize, and the cleanup report through commandCleanup. The shared read cancellation now carries the reader's partial observation, and resource-signal reports accept provider detail. * fix(pwntools): report a failed command's output once and expect resource_constraint for overflow The shared outcome owner already attaches the command's output as capturedOutput, so the pwntools adapter fallback no longer copies the same text into diagnostics.stdout, diagnostics.stderr and diagnostics.captured_output; diagnostics keep the exit facts. Update the overflow expectations the dialect migration missed (layout provider cleanup and over-budget rows, pwntools cleanup) to resource_constraint. * refactor(wasm): leave WABT cancellation to the shared owners WabtFailures matched any Error named AbortError as a cancellation. No WABT path produces one: reads, path checks and owned commands report cancellation as ArtifactReaderFailure or OwnedCommandFailure, which classifyProviderFailure and classifyProviderOutcome already classify with the caller's reason. The provider's two signal checks now build the cancellation with cancelledBy. Lowers the AnalysisCancelledError constructor baseline for both WABT files to zero. * fix(wasm): report a cancelled snapshot write as the caller's cancellation The private snapshot write passed the caller's signal to Node's writeFile, whose abort envelope reached the dialect's unclassified output failure once the name-based AbortError guess was removed. The write now turns the envelope carrying its own signal's reason into cancelledBy at the producer. * refactor(firmware): classify firmware failures through the shared provider classifier (#10810) Firmware producers now report their own deadline expiry: the start check, the output inventory and launcher admission throw the phase timeout where they observe the abort, and a read the phase signal cancelled reports it through the dialect's interruption. The classifier no longer rereads a cancellation's reason as a timeout. A new readCleanup hook keeps firmware's cleanup report shape. * refactor(captures): classify TShark, sigrok and pcap failures through the shared provider classifier TsharkCaptureProvider and SigrokRecordingProvider replace #failure with a dialect, and PcapProvider replaces analysisFailure and the tool-identity classifier. ArtifactAnalysisResources exposes its command context and a readCleanupFailure composer so the readCleanup hook keeps each provider's cleanup report shape. * refactor(jeb): classify JEB failures through the shared provider classifier JEB's raw MCP failures go through classifyProviderFailure with a JEB dialect; a typed attribution step reports a shared phase's failure under the REA operation. Each MCP phase deadline now reports its own interruption when it aborts, deciding a cancellation's owner from the caller's own signal instead of comparing abort reasons. A refusal carrying the JVM's OutOfMemoryError report becomes a resource constraint naming JEB's Java heap. * fix(jeb): advise the JVM limit that governs the reported memory area * refactor(ghidra): classify Ghidra failures through the shared provider classifier PSP extension inspection reports through classifyProviderFailure with a Ghidra dialect. The startup deadline decides at abort time whether the shared startup owner closed it, so Ghidra and Hopper no longer compare the abort reason with the owner's sentinel, and Ghidra's startup no longer compares a producer cancellation's reason with the deadline's. Three helpers that only construct one error kind now name that kind instead of AnalysisError. * refactor(hopper): classify original-source read failures through the shared provider classifier (#10838) * test(ghidra): pin the aborted startup deadline over a producer cancellation * refactor(kuna): classify Kuna failures through the shared provider classifier Session operations, the workspace copy and the project export report raw failures through classifyProviderFailure with Kuna dialects; the copy and export keep their cleanup report shapes through the readCleanup hook. * refactor(adb): report a pulled file's digest failure from its own type * refactor(sqlite): classify worker-reply read failures through the shared provider classifier * refactor(ida): classify IDA operation failures through the shared provider classifier * refactor(process): let artifact-resource consumers classify through the shared provider classifier (#10867) * test(providers): pin attribution of a cleanup-failed read's typed primary * refactor(sqlite): classify database failures through the shared provider classifier * refactor(providers): keep a cancelled read's partial observation and provider diagnostics * refactor(ghidra): classify Ghidra file failures through the shared provider classifier * refactor(ghidra): classify Ghidra failures through the shared provider classifier (#10836) * refactor(ghidra): classify Ghidra failures through the shared provider classifier PSP extension inspection reports through classifyProviderFailure with a Ghidra dialect. The startup deadline decides at abort time whether the shared startup owner closed it, so Ghidra and Hopper no longer compare the abort reason with the owner's sentinel, and Ghidra's startup no longer compares a producer cancellation's reason with the deadline's. Three helpers that only construct one error kind now name that kind instead of AnalysisError. * refactor(hopper): classify original-source read failures through the shared provider classifier (#10838) * test(ghidra): pin the aborted startup deadline over a producer cancellation * refactor(kuna): classify Kuna failures through the shared provider classifier (#10843) Session operations, the workspace copy and the project export report raw failures through classifyProviderFailure with Kuna dialects; the copy and export keep their cleanup report shapes through the readCleanup hook. * chore(guards): shrink the cancellation construction baseline after merging the base * refactor(kuna): report a retained installation read's cleanup from its reader type (#10877) * refactor(kuna): report a retained installation read's cleanup from its reader type * refactor(process): share the JVM option that governs each reported memory area (#10881) * refactor(ida): classify IDA operation failures through the shared provider classifier (#10859) * refactor(ida): classify IDA operation failures through the shared provider classifier * refactor(process): let artifact-resource consumers classify through the shared provider classifier (#10867) * test(providers): pin attribution of a cleanup-failed read's typed primary * fix(javascript): read analysis workers' V8 heap exhaustion from streamed output, not retained stderr (#10890) * refactor(kuna): report a retained installation read's cleanup from its reader type * refactor(process): share the JVM option that governs each reported memory area (#10881) * fix(javascript): read analysis workers' V8 heap exhaustion from streamed output, not retained stderr * test(browser): pin web-bundle heap exhaustion reported past the retained stderr budget * refactor(process): recognise a signal's own abort through one owner (#10896) * refactor(process): recognise a signal's own abort through one owner * chore(verify): lower the direct cancellation construction baselines the stack's migrations removed * refactor(sqlite): read the owned worker's heap ceiling from one limit (#10907) * refactor(sqlite): classify the owned worker's outcomes through the shared provider classifier (#10912) * refactor(process): call the signal abort owner directly and match NaN reasons * chore(verify): lower the SQLite cancellation construction baseline the worker migration removed * feat(rizin): report a shell refusal as a typed refusal record beside rejected completion (#10925) * refactor(kuna): report installation inspection failures through one Kuna dialect (#10913) * refactor(errors): let Hopper errors carry their own presentation so the domain presenter no longer imports them (#10944) * refactor(process): recognise the remaining command aborts through the signal owner (#10906) * refactor(process): recognise the remaining command aborts through the signal owner * test(process): cover a NaN abort reason on both execFileOutput cancellation paths * fix(process): keep a successful execFile callback when the caller aborts with a null reason * test(process): abort execFileOutput while a released descendant still holds its pipes * test(process): join the late-abort command in finally so a failed readiness check still releases its descendant * refactor(errors): move Hopper errors to src/hopper and drop their tags from the domain union (#10964) * refactor(errors): move Hopper errors to src/hopper and drop their tags from the domain union * refactor(process): recognise SQLite, WABT and Flutter aborts through the signal owner (#10975) * refactor(kuna): report doctor installation failures through the shared Kuna installation dialect (#10978) * refactor(process): recognise SQLite, WABT and Flutter aborts through the signal owner * refactor(kuna): report doctor installation failures through the shared Kuna installation dialect * fix(kuna): keep installation facts on a composed read-and-close failure * style(hopper): format the moved Hopper lease and cache publisher fixture * fix(sqlite): count only the caller's own abort as a SQLite inspection cancellation (#11018) * fix(ida): count only the caller's own abort of the busy-health pause as cancellation (#11013) * test(kuna): assert the cleanup-incomplete doctor check by code and facts, not its wording * refactor(errors): report an unrecognised command outcome with the outcome the classifier examined (#11003) * refactor(errors): report an unrecognised command outcome with the outcome the classifier examined * fix(errors): add a dialect's unclassified diagnostics to the context's instead of replacing them * fix(evm): count only the caller's own abort as an EVMole inspection cancellation (#11011) * fix(server): report only startup's own abort as the caller's HTTP listen cancellation (#11017) * refactor(errors): classify domain errors from one table and generate the error catalogue from it (#11060) docs(errors): generate the error catalogue from the classification tables * refactor(errors): report unrecognised pcap, WABT and producer-command outcomes with the examined outcome (#11044) * refactor(errors): report unrecognised pcap, WABT and producer-command outcomes with the examined outcome * fix(pcap): keep the packet summary when only the DNS wire pass reports an unrecognised outcome * refactor(ida): require the host platform for IDA MCP connections and snapshot the child environment with it (#11073) * refactor(verify): count plain throws in parser-folder process-lifecycle owners (#11071) JadxWorkspaceRoot and PwntoolsDecoder are exempt from parser-plain-throw because their plain throws report a private helper's process failures. The exemption left later throws in those files unchecked. A counted lifecycle-plain-throw guard now records their current throws (4 and 1); the baseline may only shrink, so a parse fault or defect added there must use ParseFailureError or invariantViolation. * fix(native): report a signature inspection defect as an adapter failure (#11069) withSignatureTarget wrapped every throw from the inspection callback as AnalysisOutputError("Native output parsing failed"), so an InternalInvariantError (a REA defect) was reported as malformed native command output. A defect now leaves the owned work, so runOwned releases the private signature copy first and reports the defect as the native provider's adapter failure. If releasing the copy also fails, the defect stays primary and the cleanup failure joins it through the shared cleanup composition (analysisErrorWithCleanupFailure + bindCleanupDependencies). * refactor(verify): give the javascript verifiers' roots to VerifierFixture (#11068) * refactor(verify): give the javascript verifiers' roots to VerifierFixture VerifierFixture.retain(reason) keeps a root that an owned command whose cleanup is incomplete may still use, replacing each verifier's local retain flag and cleanup closure. * refactor(verify): give the Ghidra COM, DOS, 6502, NativeAOT and raw verifiers' workspaces to VerifierFixture (#11070) * refactor(verify): give the Ghidra COM, DOS, 6502, NativeAOT and raw verifiers' workspaces to VerifierFixture * refactor(verify): keep the Ghidra decompiler-failure, decompile-timeout and no-return workspaces through VerifierFixture until owned cleanup is verified (#11077) * feat(artifacts): surface the named integrity check in public artifact errors (#11052) * feat(artifacts): surface the named integrity check in public artifact errors ArtifactOperationError now carries integrityCheck from the reader failure and projects it as details.integrity_check, including with artifact integrity details. Rebuild sites copied a different subset of reader facts each (ProcessCli.artifactFailureFacts, withCleanup, desktop, file-operation cleanup, resource export, DMG inventory, safe output tree); they now spread ArtifactReaderFailure.primaryFacts(), so a new reader fact has one owner. ArtifactIntegrityCheck moves to the domain beside ArtifactAdmissionLimit. * test(artifacts): check rebuilt cleanup failures keep the named integrity check * refactor(adb): report a pulled file's digest failure from its own type (#10848) * fix(pcap): report a refused tool launch as an unavailable tool When a capture read's tool launch was refused with EPERM, pcap reported it as unreadable tool output (AnalysisProtocolError) instead of an unavailable tool. Pcap also never told "not executable" apart from "missing". Add classifyLaunchFailure in src/process as the one owner of which spawn errnos mean missing (ENOENT, ENOTDIR) and which mean present but not executable (EACCES, EPERM, ENOEXEC, EISDIR). Pcap, apktool and gdb used three different errno lists; all three now use it. * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * refactor(process): classify Java and adb launch refusals with the shared owner (#10598) The Ghidra and JADX Java probes and adb's version probe now take missing-versus-not-executable from classifyLaunchFailure instead of their own errno checks. ELOOP and ENAMETOOLONG join the owner's missing set, so adb keeps its existing classification and both Java probes now treat a non-directory path component as a missing runtime. * fix(pcap): preserve command launch attribution * test(pcap): expect an unknown failing stage when a limited capture tool exits unsuccessfully * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * test(lint): cover baselined files in the provider-failure classifier rule * fix(apktool): report the decoder JVM's heap exhaustion as memory, not a target refusal The supervisor now watches for a managed runtime's out-of-memory report while output streams (JVM java.lang.OutOfMemoryError, V8 'JavaScript heap out of memory'), so a retention budget cannot hide it. ProviderOutcome gains a runtime-exhausted kind and classifyProviderOutcome maps it once. Apktool decode opts in and moves to the shared classifier; Ghidra's single-purpose output token becomes the JVM runtime option and its area matching reuses the shared table. * fix(process): keep the runtime's out-of-memory report on the memory error it supports * fix(pcap): attribute a limited capture's exit through the prlimit wrapper * fix(process): keep a shortened out-of-memory line marked as shortened * fix(process): identify the refused executable for every launcher shape Name the executable on errnos Node throws synchronously from spawn (ENOEXEC, ENOTDIR, ...) and read the Windows native launcher's executable-launch constraint, so pcap attributes those refusals to the selected tool or limiter instead of an unknown stage. * test(pcap): prove synchronous launch naming with ENOTDIR on every POSIX host * fix(apktool): advise the JVM limit that governs the reported memory area * fix(ghidra): read the supervisor's parsed OOM area instead of reparsing lines * fix(sqlite,capture): read V8 heap exhaustion from streamed output, not retained stderr (#10724) The SQLite worker and the Node capture decoders now declare runtime: "v8", so the supervisor observes V8's heap report as output streams. Both classifiers read the runtime-exhausted outcome instead of matching retained stderr, so a report beyond the retention budget, or one whose process then overflowed its output budget, is still reported as memory exhaustion. * refactor(evm): classify EVMole worker outcomes through the shared provider classifier (#10716) * refactor(evm): classify EVMole worker outcomes through the shared provider classifier The EVMole worker's cancellation, deadline, output budget and CPU/file-size signals now go through classifyProviderOutcome; only the prlimit launch refusal and the reserved EFBIG exit remain in its dialect. The worker is opted into V8 exhaustion scanning so a heap report names its fixed 256 MiB heap. providerOutcomeOf now reads a launch refusal only from a spawn errno, so a private-storage or carrier read errno is no longer reported as a limiter launch failure. * fix(evm): keep a stream failure's exit status and update Linux worker expectations * refactor(process): read launch refusals through the launcher identity owner * refactor(wasm): classify WABT command outcomes through the shared provider classifier (#10727) * refactor(wasm): classify WABT command outcomes through the shared provider classifier WABT's cancellation, command deadline, output budget, and inherited-limit signals now go through classifyProviderOutcome; its dialect keeps only the configuration-probe and launch-refusal unavailability and the unclassified-exit output error. A tool ended by SIGXCPU/SIGXFSZ or the memory limit is now a resource constraint instead of an output error, and a refused launch in the producer phase is reported as unavailable. The shared timeout context gains the analysis setting that selected the deadline, and the output-limit context may name its exceeded budget. * fix(wasm): keep setup guidance when a WABT version probe's output cannot be collected * refactor(providers): classify raw provider failures through one owner * refactor(process): build classified cancellations with cancelledBy and the carried caller reason * chore(lint): count runOwned's close-failure mapper from main in the classifier baseline * fix(process): carry the runtime's exhaustion report on every memory error that claims it SQLite and historical-capture memory errors recognised a streamed V8 heap report but dropped it, so a report outside retained output reached callers without its source line or omission flags. One projection, runtimeExhaustionReport, now owns that shape for the shared classifier and both consumers. Also lowers the EVMole and WABT cancellation-constructor baselines. * fix(process): keep the provider's recovery for a native-thread exhaustion report The shared classifier replaced the provider-supplied recovery with generic capacity advice whenever the JVM reported it could not create a native thread, dropping Apktool's launcher guidance and flipping retryable to true. The provider's recovery now wins; the capacity advice remains the fallback for providers that supply none. * refactor(pwntools): classify pwntools failures through the shared provider classifier (#10782) * refactor(pwntools): classify pwntools failures through the shared provider classifier pwntools' per-site classifier is replaced by pwntoolsFailureDialect for classifyProviderFailure. Command outcomes go through classifyProviderOutcome, launch refusals through launcherRefusalOf instead of a 'spawn ' syscall prefix check, the input limit through the file dialect's fileSize, and the cleanup report through commandCleanup. The shared read cancellation now carries the reader's partial observation, and resource-signal reports accept provider detail. * fix(pwntools): report a failed command's output once and expect resource_constraint for overflow The shared outcome owner already attaches the command's output as capturedOutput, so the pwntools adapter fallback no longer copies the same text into diagnostics.stdout, diagnostics.stderr and diagnostics.captured_output; diagnostics keep the exit facts. Update the overflow expectations the dialect migration missed (layout provider cleanup and over-budget rows, pwntools cleanup) to resource_constraint. * refactor(wasm): leave WABT cancellation to the shared owners WabtFailures matched any Error named AbortError as a cancellation. No WABT path produces one: reads, path checks and owned commands report cancellation as ArtifactReaderFailure or OwnedCommandFailure, which classifyProviderFailure and classifyProviderOutcome already classify with the caller's reason. The provider's two signal checks now build the cancellation with cancelledBy. Lowers the AnalysisCancelledError constructor baseline for both WABT files to zero. * fix(wasm): report a cancelled snapshot write as the caller's cancellation The private snapshot write passed the caller's signal to Node's writeFile, whose abort envelope reached the dialect's unclassified output failure once the name-based AbortError guess was removed. The write now turns the envelope carrying its own signal's reason into cancelledBy at the producer. * refactor(firmware): classify firmware failures through the shared provider classifier (#10810) Firmware producers now report their own deadline expiry: the start check, the output inventory and launcher admission throw the phase timeout where they observe the abort, and a read the phase signal cancelled reports it through the dialect's interruption. The classifier no longer rereads a cancellation's reason as a timeout. A new readCleanup hook keeps firmware's cleanup report shape. * refactor(captures): classify TShark, sigrok and pcap failures through the shared provider classifier TsharkCaptureProvider and SigrokRecordingProvider replace #failure with a dialect, and PcapProvider replaces analysisFailure and the tool-identity classifier. ArtifactAnalysisResources exposes its command context and a readCleanupFailure composer so the readCleanup hook keeps each provider's cleanup report shape. * refactor(jeb): classify JEB failures through the shared provider classifier JEB's raw MCP failures go through classifyProviderFailure with a JEB dialect; a typed attribution step reports a shared phase's failure under the REA operation. Each MCP phase deadline now reports its own interruption when it aborts, deciding a cancellation's owner from the caller's own signal instead of comparing abort reasons. A refusal carrying the JVM's OutOfMemoryError report becomes a resource constraint naming JEB's Java heap. * fix(jeb): advise the JVM limit that governs the reported memory area * refactor(ghidra): classify Ghidra failures through the shared provider classifier PSP extension inspection reports through classifyProviderFailure with a Ghidra dialect. The startup deadline decides at abort time whether the shared startup owner closed it, so Ghidra and Hopper no longer compare the abort reason with the owner's sentinel, and Ghidra's startup no longer compares a producer cancellation's reason with the deadline's. Three helpers that only construct one error kind now name that kind instead of AnalysisError. * refactor(hopper): classify original-source read failures through the shared provider classifier (#10838) * test(ghidra): pin the aborted startup deadline over a producer cancellation * refactor(kuna): classify Kuna failures through the shared provider classifier Session operations, the workspace copy and the project export report raw failures through classifyProviderFailure with Kuna dialects; the copy and export keep their cleanup report shapes through the readCleanup hook. * refactor(adb): report a pulled file's digest failure from its own type * refactor(ghidra): classify Ghidra failures through the shared provider classifier (#10836) * refactor(ghidra): classify Ghidra failures through the shared provider classifier PSP extension inspection reports through classifyProviderFailure with a Ghidra dialect. The startup deadline decides at abort time whether the shared startup owner closed it, so Ghidra and Hopper no longer compare the abort reason with the owner's sentinel, and Ghidra's startup no longer compares a producer cancellation's reason with the deadline's. Three helpers that only construct one error kind now name that kind instead of AnalysisError. * refactor(hopper): classify original-source read failures through the shared provider classifier (#10838) * test(ghidra): pin the aborted startup deadline over a producer cancellation * refactor(kuna): classify Kuna failures through the shared provider classifier (#10843) Session operations, the workspace copy and the project export report raw failures through classifyProviderFailure with Kuna dialects; the copy and export keep their cleanup report shapes through the readCleanup hook. * chore(guards): shrink the cancellation construction baseline after merging the base * refactor(ida): let IDA close failures read the session's later close (#10811) * refactor(errors): read cleanup completion from dependencies instead of pushing it to dependents AnalysisError.cleanupIncomplete becomes a getter over the error's own unresolved state and its bound dependencies. The WeakRef dependents graph and resolveCleanup's push propagation are removed, and subclasses mark their initial state through markCleanupIncomplete instead of overriding a public mutable field. * fix(errors): settle bound dependencies before binding more A composite whose dependencies had released but whose status was never read stayed incomplete when a later dependency was bound. * refactor(errors): let errors read a lease group's release instead of resolving them (#10759) AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink (#10763) * refactor(errors): let errors read a lease group's release instead of resolving them AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink * refactor(process): let worker cleanup errors read their root epoch's release OwnedWorkerRuntime's root epoch is now an AnalysisCleanupReleaseClaim. Errors bound to it read its release when asked instead of the epoch pushing resolveCleanup() through weak references, and a runtime without a retained root binds an already-released owner. Removes the OwnedWorkerCleanupFailure structural type and four resolveCleanup() pushes; the counted baseline shrinks accordingly. * refactor(pcap): let pcap cleanup errors read command and snapshot release (#10792) Retained pcap commands, retained snapshot failures and snapshot completion descriptors now own their release and errors read it: commands and snapshot failures implement AnalysisCleanupReleaseClaim, and a failed completion-descriptor close is retried through an AnalysisCleanupLease bound to its error. Removes four resolveCleanup() pushes; the counted baseline shrinks accordingly. * refactor(process): let Darwin helper cleanup errors read their owner's release Darwin helper cache and run-token reader root cleanup now record an AnalysisCleanupRelease that every failure reports; a successful retry confirms it. Replaces the first-failure anchor that later failures depended on and the resolveCleanup() push. Removes two resolveCleanup() and two bindCleanupDependencies() calls; both counted baselines shrink. * refactor(ghidra): let Ghidra cleanup errors read the client's and checkpoint's release GhidraClient and GhidraCheckpoint bind each cleanup failure to an AnalysisCleanupRelease and confirm it when a later close or retry releases everything, instead of keeping a set of failures and pushing resolveCleanup() to each. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(process): let debugger session cleanup errors read a confirmed stop OwnedDebuggerSessionRegistry binds each retained gdb or rizin cleanup failure to the session's AnalysisCleanupRelease and confirms it when a stop is confirmed, keeping the latest failure for retry reporting, instead of pushing resolveCleanup() to a set of failures. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(process): drop the debugger registry's unused closeOperation option Returning the latest retained failure removed the last reader of closeOperation; remove the option and the values gdb and rizin supplied. * refactor(server): let environment shutdown errors read a successful close serveEnvironment binds each shutdown failure to an AnalysisCleanupRelease that a later successful close confirms, instead of pushing resolveCleanup() to a set of failures. The state-file retry test now also requires the earlier report to read the release. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(desktop): release retained screen-judge cleanup through its lease Each retained judge or screenshot cleanup owner is wrapped in an AnalysisCleanupLease bound to its failure; close() releases the lease, which records the release the failure reads, instead of closing the owner and pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(ida): let IDA close failures read the session's later close IdaSessionClient's close failure binds an owner that is both its resource owner and its release claim, read from the client's closed state, instead of keeping weak references and pushing resolveCleanup() after a successful retry. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(javascript): let source-map codec cleanup errors read a later close (#10814) * refactor(javascript): let source-map codec cleanup errors read a later close OwnedCodec binds each close failure to an AnalysisCleanupRelease that a later successful close confirms, replacing the first-failure anchor that later failures depended on and the resolveCleanup() push. Removes one resolveCleanup() and one bindCleanupDependencies() call; both counted baselines shrink. * refactor(cutter): let pending Cutter command errors read the completion receipt (#10815) * refactor(cutter): let pending Cutter command errors read the completion receipt Each pending Cutter command keeps an AnalysisCleanupRelease bound to its timeout failure; the producer's terminal completion receipt confirms it instead of pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(application): let provider candidate cleanup errors read the candidate's close (#10817) * refactor(application): let provider candidate cleanup errors read the candidate's close AnalysisProviderRegistry keeps one AnalysisCleanupRelease per candidate whose resource close is unconfirmed; failures bind to it and a later confirmed close confirms it, instead of pushing resolveCleanup() to a set of failures. Removes one resolveCleanup() call; the counted baseline shrinks. * fix(errors): bind a cleanup release claim to an error at most once AnalysisError kept release claims in an array, so a provider whose retried close returned the same error bound the same claim again on every retry and each cleanupIncomplete read scanned the duplicates. Keep the claims in a set. * refactor(application): let reverse-tool cleanup errors read a verified stop (#10819) * refactor(application): let reverse-tool cleanup errors read a verified stop Each retained provider process group in ReverseEngineeringService keeps an AnalysisCleanupRelease; its command and retry failures bind to it and a later verified stop confirms it, instead of collecting failures and pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(sqlite): let SQLite worker and root cleanup errors read their release (#10821) Each retained SQLite snapshot cleanup records an AnalysisCleanupRelease for its worker and for its runtime root; the resource failures bind to them and a verified stop or root removal confirms them, instead of pushing resolveCleanup(). Composite failures keep reading those resource failures. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(application): let JADX and session close failures read their owner's release (#10854) * refactor(android): let JADX cleanup errors read their retained cleanup's release Each retained JADX cleanup records an AnalysisCleanupRelease for the admission failure's descriptor owners and one for the whole retained cleanup. The admission failure and every error the cleanup reports bind to them, and a confirmed close confirms them, instead of pushing resolveCleanup() through WeakRefs to reported errors. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(application): let session close failures read the client's later close A retained session cleanup records an AnalysisCleanupRelease; unowned cleanup failures the client's close reported bind to it and the successful close confirms it, instead of the session collecting them and pushing resolveCleanup(). Failures that already follow their own owner keep reading it. Adds a regression for an unowned close failure. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(browser): parse Runtime and Debugger events once by registered schemas (#10742) * refactor(browser): parse frame lifecycle events once by a registered event schema CdpConnection admits each event through protocol/CdpEvents.ts, which parses the five Page frame lifecycle events once into identity facts plus a frame URL observation, like a frame-tree node. Screenshot, page capture, the observation timeline, WebMCP, Electron inspection and the execution window read those facts instead of re-parsing the raw payload; CdpFrameFacts no longer carries the raw source record. Playwright CDP session subscriptions name an event from Playwright's protocol table, and an architecture guard counts the remaining raw event payload reads so they can only shrink. * refactor(browser): parse Runtime and Debugger events once by registered schemas Register Debugger.scriptParsed, Debugger.scriptFailedToParse, Runtime.executionContextCreated, Runtime.executionContextDestroyed and Runtime.consoleAPICalled. Script and context payloads carry both the tolerant facts passive capture uses and the active runtime's strict declaration, derived from one parse, plus the declaration's byte size for the runtime retention budget. Page capture, Electron script capture, the V8 Inspector provider and the runtime source inventory now read the registered payload. The cdp-raw-event-params baseline drops from 20 to 7. * refactor(browser): admit transport events through the registered-event owner Remove the unused cdpFrameUrl wrapper; its fragment cases now exercise observeCdpFrameUrl. Add a connection-level test that two subscribers share one parsed payload and the raw params. * fix(browser): report an unserializable event declaration's size instead of throwing JSON.stringify can throw on a declaration JSON.parse accepted (nesting deeper than the serializer's stack). The registry sized script and context declarations inside the connection's WebSocket callback, so such an event escaped as an uncaught exception. The size is now a Result; the runtime source inventory raises the failure inside its own catch, as before. * refactor(browser): parse Network events once by registered schemas (#10743) * refactor(browser): parse Network events once by registered schemas Register Network.requestWillBeSent, responseReceived, loadingFinished, loadingFailed, webSocketCreated and webSocketFrameSent/Received. The request payload carries the tolerant facts page capture and the timeline read plus the active runtime's strict declaration. Page capture's network and WebSocket handlers, the timeline's request tracking and the runtime request inventory now read the registered payload. The cdp-raw-event-params baseline drops from 7 to 5. * refactor(browser): drop payload helpers the capture handlers no longer use * refactor(browser): read every CDP event payload through the registry (#10745) * refactor(browser): read every CDP event payload through the registry Register Target.attachedToTarget, Target.detachedFromTarget, Page.lifecycleEvent and WebMCP.toolsAdded/toolsRemoved, and carry a requested navigation's reason and a commit's transition type in the frame-event payload. The timeline no longer threads raw params into its entries: each entry receives its timestamp, frame and loader identity explicitly. WebMCP discovery, the service-worker policy blocker and the target-event matcher read the registered payload. With no raw reads left, the cdp-raw-event-params guard is enforced at zero instead of counted. * refactor(browser): drop raw payload helpers the timeline and worker blocker no longer use * refactor(browser): type Playwright CDP session events by the registry (#10751) PlaywrightCdpSession.on subscribes only to registered events and hands the listener the payload parsed by its registered schema, returning the unsubscribe function. Private storage seeding reads registered payloads, including the events of non-flat child sessions, and applies its strict seeding policy to the parsed facts. Its local attach, detach, nested message and pause schemas and the storage-only script/context schemas are removed; Debugger.paused, Runtime.executionContextsCleared and Target.receivedMessageFromTarget join the registry. * test(browser): admit fake policy events through the event registry The service-worker policy now reads event.registered, but the PlaywrightScenarioSession fake connection delivered raw events, so three detached-target tests never reached the policy. The fake now admits each event with receiveCdpEvent as CdpConnection does. * fix(browser): fail the CDP session closed when an event listener throws (#10758) * fix(browser): fail the CDP session closed when an event listener throws An exception from a CDP event subscriber escaped CdpTransportCore's socket message callback uncaught (for example the service-worker blocker's protocol_error on a Target event without a sessionId). The transport now stops delivery, fails the connection as a protocol error whose cause is the listener's exception, rejects pending and later commands with it, and notifies protocol-failure subscribers. The Playwright CDP session relay applies the same rule to its event listeners. * fix(browser): report a failed service-worker policy connection at the next policy check The policy's event listener rejects a malformed Target event, which now fails its connection. With no policy command pending, nothing reported it and later iframe targets went unprotected. The policy records its connection's protocol failure and assertBlocked, run before each scenario step, rethrows it. * fix(browser): keep cleanup commands available after a listener failure A listener failure no longer marks the wire as broken. The transport still rejects pending commands, notifies protocol-failure subscribers, stops delivering events and refuses reuse, but it keeps reading replies and admits commands sent in cleanup grace. The service-worker policy can then remove its init scripts, restore the main realm, detach and release its socket. Wire-level protocol errors still refuse every later command. The PlaywrightScenarioSession policy fake gains onProtocolFailure, which the policy now subscribes to. * refactor(browser): keep raw CDP event payloads out of the received event (#10764) * refactor(browser): keep raw CDP event payloads out of the received event CdpReceivedEvent and CdpTransportEvent no longer carry params: receiveCdpEvent hands the raw payload only to the registered schema, so a subscriber cannot read it by property access, destructuring or computed keys. This supersedes the event.params text guard in architecture-guards, which is removed. * refactor(browser): read registered event payloads in the JavaScript verifiers The runtime, storage and URL-userinfo verifiers subscribe to CdpConnection, which no longer hands subscribers raw params. They now read event.registered. A test scans every scripts/ onEvent callback for raw payload reads, since the TypeScript check does not cover them. The storage verifier's pause trace records a malformed pause instead of the unregistered reason member. * refactor(browser): track the timeline's main frame with the document tracker (#10779) TimelineCapture kept its own mutable main frame id and replaced it on a root replacement. It now holds the CdpDocumentTracker that CdpTargetSession owns and observes the replacement document through it; every main-frame check (lifecycle, navigation, document request, redirect) reads the tracker's current frame. A characterization test pins that the replaced root's lifecycle events are no longer recorded. * refactor(browser): select CDP events only by their registered name (#10829) CdpReceivedEvent carried the wire method as a plain string, so a subscriber could compare it with a misspelt or unregistered name and the check compiled but never matched. Three owners selected Inspector.targetCrashed, an unregistered event, that way. Register Inspector.targetCrashed and drop the wire method from the received event. Subscribers select events by registered.method, whose type is the registered event names. The capture coverage start keeps reading the wire domain, now the event's domain field. * fix(browser): retire a policy child session that CDP reports gone After a listener failure the connection stops delivering events, so an iframe's Target.detachedFromTarget never retires its policy target. Cleanup then sent Page.removeScriptToEvaluateOnNewDocument to the dead session, kept the stale child, and every retry failed before detaching the root. The service-worker policy owner now treats CDP's session-not-found rejection as proof that the child is gone and retires it. The classifier moves from CdpTargetSession to CdpCommandRejection, its owner, and the target-session detach path uses the same one. * refactor(browser): route target events through one session owner (#10835) * refactor(browser): route target events through one session owner Page capture, WebMCP discovery, screenshot capture and the runtime sources each compared the envelope session ID themselves, while the observation window and execution collection used cdpTargetEventMatches, which also routes the root Target.detachedFromTarget that names the target's session. onCdpTargetEvent in CdpTargetEvents.ts now subscribes every target consumer with that one rule; the matcher is private and the per-subscriber comparisons are removed. Electron inspection keeps its own filter while its capture isolation awaits a maintainer decision. * fix(browser): report WebMCP subframe tools whose document is unverified (#10839) * fix(browser): report WebMCP subframe tools whose document is unverified A committed subframe navigation kept the frame's tools silently when CDP reported no loader at the same URL, and removed them on any URL change even when the loader proved the same document. Each frame now carries a CdpDocumentTracker, the session's document identity owner. Only a proven change removes the frame's tools. An unknown comparison keeps them visible, marks webmcp_tools attach-limited and names the frames whose document identity could not be established. * test(browser): prove an unverified live subframe limits WebMCP coverage * fix(browser): key a WebMCP registration by its frame and tool name A subframe tool kept across a committed navigation that changed the URL but not the loader was stored under a key built from the old URL, so a later toolsAdded for the same frame and name added a second entry. Registrations are now keyed by frame and name; tool_key still records the registering frame URL. * test(browser): deliver fake CDP events through the transport's admission (#10840) Event fakes each rebuilt the received event: CdpAgentHints typed its listeners as raw wire events behind an unknown cast, and the Electron, scenario-session and routing tests each wrapped receiveCdpEvent by hand. fakeCdpEvents (tests/fixtures) is a CdpConnection.onEvent fake whose emit admits each raw event with receiveCdpEvent and the wire byte count, so a change to the received event shape fails at the fake instead of silently not exercising subscribers. * refactor(browser): own the selected page generation in one target document tracker (#10860) * refactor(browser): own the selected page generation in one target document tracker Page capture, screenshot, the observation window, the runtime session and the execution window each built a document tracker or rule of their own from root-frame navigation events. CdpTargetDocument now follows the target session's root-frame events and the frame-tree replies its consumers read, classifies root identity once, and reports each navigation to consumers that decide only what it means for their evidence. * fix(browser): report a lost scenario policy connection before the next step (#10864) * fix(browser): report a lost scenario policy connection before the next step The service-worker policy recorded only protocol failures. When its CDP socket closed or its page session detached, later documents lost the blocking script, but the scenario learned of it only when a frame check found an unprotected realm. The owner now records the disconnect or detach when CDP reports it; the next policy check and the next step's action report it first. * fix(browser): refuse an unregistered CDP command before it reaches the browser (#10868) JavaScript verifiers can name any command, and the send owners refused an unregistered one only when its reply arrived, after the browser had acted on it. CdpConnection and the Playwright session now refuse the name before sending, and the Playwright session refuses an unregistered event name instead of subscribing to events no listener receives. The verifier text scan stays as an early warning and documents what it cannot see. * fix(browser): keep a proven root change and the loaderless selection's uncertainty Two review findings on the target document owner. A root event naming another frame with a malformed loader set `changed` but was announced as unidentified, so the execution window failed with protocol_error and dropped what it had collected; the owner now announces it as the proven change it is. The runtime session compared each frame-tree reply with the tracker's current document, which can learn a loader from an event, so a loaderless selection followed by an event and a reply with that loader compared as same; it now compares the reply with the selected document through the owner, and reports target_changed as before. * test(browser): refuse the next scenario step after the policy session detaches * refactor(browser): read WebMCP document identity from the target document owner (#10884) * refactor(browser): read WebMCP document identity from the target document owner WebMCP discovery compared the first and last frame-tree roots itself and kept a document tracker per subframe. CdpTargetDocument now follows the selected root and each committed subframe for it: the final frame tree feeds the owner, a root change proven by a navigation event during discovery is target_changed as in page capture, and a subframe whose committed document changed loses its tools. A subframe navigation without a loader still keeps the tools and reports them as unverified. * fix(browser): start a subframe first seen within its document with an unknown loader A subframe absent from the initial frame tree and first seen through Page.navigatedWithinDocument had no document tracker, so a later commit started a fresh one and the tools it registered meanwhile lost the unverified-document limitation. The owner now starts such a subframe with an unknown loader. * fix(browser): refuse a verifier's unregistered CDP event name at subscription (#10885) JavaScript verifiers subscribed to every event with CdpConnection.onEvent and compared registered.method with a string literal. A misspelt or unregistered name never matched and the verifier waited until its timeout. CdpConnection.onRegisteredEvent now takes one event name, refuses an unregistered one before subscribing (the same registry check the Playwright session applies), and hands the listener only that event's registered parse. The verifiers subscribe only through it, and the evaluation test rejects a raw onEvent subscription in scripts. * fix(browser): keep subframe documents by frame and loader without their URLs * refactor(domain): give strict UTF-8 decoding one owner with an explicit BOM policy (#10728) * refactor(domain): give strict UTF-8 decoding one owner with an explicit BOM policy * fix(domain): keep the leading-BOM behaviour every migrated UTF-8 decoder had * refactor(domain): read the domain layer's strict UTF-8 through the BOM-policy owner (#10803) Twelve domain decoders built their own fatal TextDecoder with ignoreBOM: true. They now use strictUtf8Decoder("preserve"), which keeps that behaviour: each reads bytes where a leading U+FEFF is content (binary-format names and fields, JSON and XML read byte-for-byte, recorded bodies, registry seeds whose kept bytes are re-emitted). The counted baseline drops from 74 to 62. * refactor(artifacts): read artifact readers' strict UTF-8 through the BOM-policy owner (#10871) Fourteen artifact reader modules (17 sites) built their own fatal TextDecoder. They now take it from strictUtf8Decoder with the policy each had: every one kept a leading BOM (ignoreBOM: true), so they use "preserve"; JavaScriptArtifactFiles keeps it for JavaScript and HTML entries and strips it otherwise, as before. The strict-utf8-decoder baseline drops those 17 sites. * refactor(domain): drop TextDecoder imports left by the strict UTF-8 migration * refactor(application): read MCP registration metadata through the strict UTF-8 owner * refactor(formats): read binary-format readers' strict UTF-8 through the BOM-policy owner (#10903) * refactor(formats): read binary-format readers' strict UTF-8 through the BOM-policy owner * refactor(formats): drop the model readers' unused TextDecoder imports * refactor(browser): read browser capture and fetch strict UTF-8 through the BOM-policy owner (#10935) * refactor(browser): read browser capture and fetch strict UTF-8 through the BOM-policy owner * refactor(native): read LLDB and Mach-O name strict UTF-8 through the BOM-policy owner (#10936) * refactor(native): read LLDB and Mach-O name strict UTF-8 through the BOM-policy owner * refactor(process): read MCP and NDJSON transport frames' strict UTF-8 through the BOM-policy owner (#10937) * refactor(process): read MCP and NDJSON transport frames' strict UTF-8 through the BOM-policy owner * refactor(application): read JSON and file inputs' strict UTF-8 through the BOM-policy owner (#10938) * refactor(application): read JSON and file inputs' strict UTF-8 through the BOM-policy owner * refactor(providers): read IDA, Electron, Ghidra and reference strict UTF-8 through the BOM-policy owner (#10939) * refactor(providers): read IDA, Electron, Ghidra and reference strict UTF-8 through the BOM-policy owner * refactor(evm): read the hex bytecode carrier's strict UTF-8 through the owner and refuse new local decoders (#10940) * refactor(evm): read the hex bytecode carrier's strict UTF-8 through the BOM-policy owner * chore(architecture): match local strict UTF-8 decoders in any option order * fix(il2cpp): resolve ELF ABS64 and GLOB_DAT image definitions (#11075) Derive bounded ELF ABS64 and GLOB_DAT link-image values for IL2CPP module scanning while preserving the default conservative relocation policy. Retain ambiguous hash declarations, validate complete hash-table mappings, and disclose runtime-binding limitations in CLI and MCP evidence. Validation: 408 focused tests, check:fast and docs:check passed. Public CLI/MCP and independently linked ARM64/x86-64 ELF arithmetic were checked; the original Unity binaries remain unavailable. Refs #10478 Related: #10495 Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com> * fix(il2cpp): read ELF hash-table words through BinaryReader (#11083) * test(pcap): check the retained DNS-pass summary by coverage, not limitation wording * refactor(reverse): fake objdump and Rizin commands only through the owned supervisor (#11076) * refactor(reverse): fake objdump and Rizin commands only through the owned supervisor * test(reverse): fake launch refusals and failed exits as the owned supervisor reports them * refactor(reverse): name objdump and Rizin command repairs through the command port (#11080) * refactor(desktop): let build-computer and agentenv cleanup errors read their owner's release (#10855) * refactor(errors): read cleanup completion from dependencies instead of pushing it to dependents AnalysisError.cleanupIncomplete becomes a getter over the error's own unresolved state and its bound dependencies. The WeakRef dependents graph and resolveCleanup's push propagation are removed, and subclasses mark their initial state through markCleanupIncomplete instead of overriding a public mutable field. * fix(errors): settle bound dependencies before binding more A composite whose dependencies had released but whose status was never read stayed incomplete when a later dependency was bound. * refactor(errors): let errors read a lease group's release instead of resolving them (#10759) AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink (#10763) * refactor(errors): let errors read a lease group's release instead of resolving them AnalysisCleanupLeaseGroup no longer calls resolveCleanup() on its error. The error holds the group as a release claim and reads cleanupReleased when asked, so completion follows the lease owner without a push. * chore(verify): count resolveCleanup and bindCleanupDependencies calls so they only shrink * refactor(process): let worker cleanup errors read their root epoch's release OwnedWorkerRuntime's root epoch is now an AnalysisCleanupReleaseClaim. Errors bound to it read its release when asked instead of the epoch pushing resolveCleanup() through weak references, and a runtime without a retained root binds an already-released owner. Removes the OwnedWorkerCleanupFailure structural type and four resolveCleanup() pushes; the counted baseline shrinks accordingly. * refactor(pcap): let pcap cleanup errors read command and snapshot release (#10792) Retained pcap commands, retained snapshot failures and snapshot completion descriptors now own their release and errors read it: commands and snapshot failures implement AnalysisCleanupReleaseClaim, and a failed completion-descriptor close is retried through an AnalysisCleanupLease bound to its error. Removes four resolveCleanup() pushes; the counted baseline shrinks accordingly. * refactor(process): let Darwin helper cleanup errors read their owner's release Darwin helper cache and run-token reader root cleanup now record an AnalysisCleanupRelease that every failure reports; a successful retry confirms it. Replaces the first-failure anchor that later failures depended on and the resolveCleanup() push. Removes two resolveCleanup() and two bindCleanupDependencies() calls; both counted baselines shrink. * refactor(ghidra): let Ghidra cleanup errors read the client's and checkpoint's release GhidraClient and GhidraCheckpoint bind each cleanup failure to an AnalysisCleanupRelease and confirm it when a later close or retry releases everything, instead of keeping a set of failures and pushing resolveCleanup() to each. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(process): let debugger session cleanup errors read a confirmed stop OwnedDebuggerSessionRegistry binds each retained gdb or rizin cleanup failure to the session's AnalysisCleanupRelease and confirms it when a stop is confirmed, keeping the latest failure for retry reporting, instead of pushing resolveCleanup() to a set of failures. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(process): drop the debugger registry's unused closeOperation option Returning the latest retained failure removed the last reader of closeOperation; remove the option and the values gdb and rizin supplied. * refactor(server): let environment shutdown errors read a successful close serveEnvironment binds each shutdown failure to an AnalysisCleanupRelease that a later successful close confirms, instead of pushing resolveCleanup() to a set of failures. The state-file retry test now also requires the earlier report to read the release. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(desktop): release retained screen-judge cleanup through its lease Each retained judge or screenshot cleanup owner is wrapped in an AnalysisCleanupLease bound to its failure; close() releases the lease, which records the release the failure reads, instead of closing the owner and pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(ida): let IDA close failures read the session's later close IdaSessionClient's close failure binds an owner that is both its resource owner and its release claim, read from the client's closed state, instead of keeping weak references and pushing resolveCleanup() after a successful retry. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(javascript): let source-map codec cleanup errors read a later close (#10814) * refactor(javascript): let source-map codec cleanup errors read a later close OwnedCodec binds each close failure to an AnalysisCleanupRelease that a later successful close confirms, replacing the first-failure anchor that later failures depended on and the resolveCleanup() push. Removes one resolveCleanup() and one bindCleanupDependencies() call; both counted baselines shrink. * refactor(cutter): let pending Cutter command errors read the completion receipt (#10815) * refactor(cutter): let pending Cutter command errors read the completion receipt Each pending Cutter command keeps an AnalysisCleanupRelease bound to its timeout failure; the producer's terminal completion receipt confirms it instead of pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(application): let provider candidate cleanup errors read the candidate's close (#10817) * refactor(application): let provider candidate cleanup errors read the candidate's close AnalysisProviderRegistry keeps one AnalysisCleanupRelease per candidate whose resource close is unconfirmed; failures bind to it and a later confirmed close confirms it, instead of pushing resolveCleanup() to a set of failures. Removes one resolveCleanup() call; the counted baseline shrinks. * fix(errors): bind a cleanup release claim to an error at most once AnalysisError kept release claims in an array, so a provider whose retried close returned the same error bound the same claim again on every retry and each cleanupIncomplete read scanned the duplicates. Keep the claims in a set. * refactor(application): let reverse-tool cleanup errors read a verified stop (#10819) * refactor(application): let reverse-tool cleanup errors read a verified stop Each retained provider process group in ReverseEngineeringService keeps an AnalysisCleanupRelease; its command and retry failures bind to it and a later verified stop confirms it, instead of collecting failures and pushing resolveCleanup(). Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(sqlite): let SQLite worker and root cleanup errors read their release (#10821) Each retained SQLite snapshot cleanup records an AnalysisCleanupRelease for its worker and for its runtime root; the resource failures bind to them and a verified stop or root removal confirms them, instead of pushing resolveCleanup(). Composite failures keep reading those resource failures. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(android): let JADX cleanup errors read their retained cleanup's release Each retained JADX cleanup records an AnalysisCleanupRelease for the admission failure's descriptor owners and one for the whole retained cleanup. The admission failure and every error the cleanup reports bind to them, and a confirmed close confirms them, instead of pushing resolveCleanup() through WeakRefs to reported errors. Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(application): let session close failures read the client's later close A retained session cleanup records an AnalysisCleanupRelease; unowned cleanup failures the client's close reported bind to it and the successful close confirms it, instead of the session collecting them and pushing resolveCleanup(). Failures that already follow their own owner keep reading it. Adds a regression for an unowned close failure. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(desktop): let build-computer and agentenv cleanup errors read their owner's release Build-computer teardown, retained task readers, remote reader folders and agentenv solve sandboxes each record an AnalysisCleanupRelease that their bound failures read; a verified teardown or stop confirms it instead of pushing resolveCleanup() through WeakRef sets. Long-run job failures read whether every job they name has confirmed its stop, so a failure naming two jobs no longer reads complete when only one stops (regression added). WeakRef sets kept only where late facts (completion receipts, reader views) are still retained as diagnostics. Removes six resolveCleanup() calls; the counted baseline shrinks. * refactor(kuna): let source-map and Kuna cache cleanup errors read their owner's release (#10856) * refactor(browser): let late source-map fetch errors read their response's release A pending source-map fetch and a response cancellation each record an AnalysisCleanupRelease that their cancellation or deadline failure reads; releasing the late response or the reader lock confirms it instead of pushing resolveCleanup(). Removes two resolveCleanup() calls; the counted baseline shrinks. * refactor(kuna): let project-cache cleanup errors read each owner's release Each retained Kuna resource owner (process, staging, hash descriptor, retired file) records a release that the errors reporting it read; an error completes once every owner it reports confirms, and retirement that moves staging to a retained file forwards the staging owner's release to the file's. Replaces the WeakRef report list, its pruning and the resolveCleanup() push. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(process): forbid resolveCleanup() pushes; native markers read their supervisor's release (#10857) * refactor(providers): let an attributed client failure read its source's completed cleanup Re-attributing a failure whose source cleanup already completed now binds a claim reading that source's release instead of pushing resolveCleanup() onto the new error; a pending source is still bound as a dependency. Resources stay as history, as before. Removes one resolveCleanup() call; the counted baseline shrinks. * refactor(process): let native command markers read their supervisor's release ProviderProcessSupervisor records an AnalysisCleanupRelease that a stop proving the process ended confirms. Native command and LLDB resolver cleanup markers bind to their supervisor's release, so a verified stop by either owner completes them, instead of each owner pushing resolveCleanup() onto the markers it tracks. Removes the last two resolveCleanup() calls outside the error base; the counted baseline is empty. * chore(verify): forbid resolveCleanup() pushes outside the error base Every production owner now confirms a release its errors read, so the counted baseline is empty. The guard becomes an outright ban with no baseline entry. * test(native): complete native command and LLDB markers through a direct supervisor stop * refactor(errors): complete an error's cleanup from its owner's record and every dependency (#10892) * refactor(errors): complete an error's cleanup from its owner's record and every dependency * refactor(errors): complete test errors through an owner release and delete resolveCleanup() (#10898) * refactor(android): compose JADX and Apktool cleanup failures through one shared owner (#10900) * refactor(android): compose JADX and Apktool cleanup failures through one shared owner * refactor(application): compose service cleanup failures through the shared owner (#10902) * refactor(sqlite): classify worker-reply read failures through the shared provider classifier (#10849) * fix(pcap): report a refused tool launch as an unavailable tool When a capture read's tool launch was refused with EPERM, pcap reported it as unreadable tool output (AnalysisProtocolError) instead of an unavailable tool. Pcap also never told "not executable" apart from "missing". Add classifyLaunchFailure in src/process as the one owner of which spawn errnos mean missing (ENOENT, ENOTDIR) and which mean present but not executable (EACCES, EPERM, ENOEXEC, EISDIR). Pcap, apktool and gdb used three different errno lists; all three now use it. * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * refactor(process): classify Java and adb launch refusals with the shared owner (#10598) The Ghidra and JADX Java probes and adb's version probe now take missing-versus-not-executable from classifyLaunchFailure instead of their own errno checks. ELOOP and ENAMETOOLONG join the owner's missing set, so adb keeps its existing classification and both Java probes now treat a non-directory path component as a missing runtime. * fix(pcap): preserve command launch attribution * test(pcap): expect an unknown failing stage when a limited capture tool exits unsuccessfully * refactor(process): classify owned command outcomes through one owner Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions. * test(lint): cover baselined files in the provider-failure classifier rule * fix(apktool): report the decoder JVM's heap exhaustion as memory, not a target refusal The supervisor now watches for a managed runtime's out-of-memory report while output streams (JVM java.lang.OutOfMemoryError, V8 'JavaScript heap out of memory'), so a retention budget cannot hide it. ProviderOutcome gains a runtime-exhausted kind and classifyProviderOutcome maps it once. Apktool decode opts in and moves to the shared classifier; Ghidra's single-purpose output token becomes the JVM runtime option and its area matching reuses the shared table. * fix(process): keep the runtime's out-of-memory report on the memory error it supports * fix(pcap): attribute a limited capture's exit through the prlimit wrapper * fix(process): keep a shortened out-of-memory line marked as shortened * fix(process): identify the refused executable for every launcher shape Name the executable on errnos Node throws synchronously from spawn (ENOEXEC, ENOTDIR, ...) and read the Windows native launcher's executable-launch constraint, so pcap attributes those refusals to the selected tool or limiter instead of an unknown stage. * test(pcap): prove synchronous launch naming with ENOTDIR on every POSIX host * fix(apktool): advise the JVM limit that governs the reported memory area * fix(ghidra): read the supervisor's parsed OOM area instead of reparsing lines * fix(sqlite,capture): read V8 heap exhaustion from streamed output, not retained stderr (#10724) The SQLite worker and the Node capture decoders now declare runtime: "v8", so the supervisor observes V8's heap report as output streams. Both classifiers read the runtime-exhausted outcome instead of matching retained stderr, so a report beyond the retention budget, or one whose process then overflowed its output budget, is still reported as memory exhaustion. * refactor(evm): classify EVMole worker outcomes through the shared provider classifier (#10716) * refactor(evm): classify EVMole worker outcomes through the shared provider classifier The EVMole worker's cancellation, deadline, output budget and CPU/file-size signals now go through classifyProviderOutcome; only the prlimit launch refusal and the reserved EFBIG exit remain in its dialect. The worker is opted into V8 exhaustion scanning so a heap report names its fixed 256 MiB heap. providerOutcomeOf now reads a launch refusal only from a spawn errno, so a private-storage or carrier read errno is no longer reported as a limiter launch failure. * fix(evm): keep a stream failure's exit status and update Linux worker expectations * refactor(process): read launch refusals through the launcher identity owner * refactor(wasm): classify WABT command outcomes through the shared provider classifier (#10727) * refactor(wasm): classify WABT command outcomes through the shared provider classifier WABT's cancellation, command deadline, output budget, and inherited-limit signals now go through classifyProviderOutcome; its dialect keeps only the configuration-probe and launch-refusal unavailability and the unclassified-exit output error. A tool ended by SIGXCPU/SIGXFSZ or the memory limit is now a resource constraint instead of an output error, and a refused launch in the producer phase is reported as unavailable. The shared timeout context gains the analysis setting that selected the deadline, and the output-limit context may name its exceeded budget. … --------- Co-authored-by: Ysopwnable <161784452+N0zoM1z0@users.noreply.github.com> Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
489 lines
27 KiB
Markdown
489 lines
27 KiB
Markdown
# Contributing to REA
|
|
|
|
REA welcomes focused bug fixes, documentation improvements, tests, and reverse-engineering workflows. For large contract or architecture changes, explain the intended scope and link the relevant issue or design discussion.
|
|
|
|
## Choosing a contribution
|
|
|
|
Explain the concrete problem, keep related corrections together, and report
|
|
verification and unavailable coverage. Contributions should justify their review
|
|
and maintenance cost. Keep cosmetic polish with useful fixes; confusing or
|
|
incorrect user instructions warrant standalone corrections. Collect other
|
|
cosmetic-only suggestions in an issue rather than separate PRs.
|
|
|
|
For selected architectural owners and dependency paths, use the
|
|
[architecture map](docs/architecture/architecture.mermaid). It is not a complete directory or
|
|
import inventory. For current provider wiring, start with
|
|
[`src/composition/binary.ts`](src/composition/binary.ts) for deep candidates and
|
|
the other `src/composition/` factories for tool services, including
|
|
[`gpu.ts`](src/composition/gpu.ts) and [`model.ts`](src/composition/model.ts).
|
|
Live Frida, Cutter, GDB and Rizin construction also uses shared composition
|
|
factories. For service ownership, availability and catalog declarations, follow
|
|
the [capability composition guide](docs/capability-composition.md).
|
|
Production factories construct fresh providers without starting engines or
|
|
acquiring targets; optional adapter failures must preserve successful peers. Run
|
|
`npm run verify:test-discovery` after adding or moving tests. Resolved import
|
|
boundaries are checked by `npm run verify:module-boundaries`, included in lint.
|
|
It also checks each top-level `src/` unit against its layer in
|
|
[`scripts/lib/module-layers.mjs`](scripts/lib/module-layers.mjs) (a new
|
|
directory must declare one) and against the counted outward, mutual,
|
|
cross-provider and past-entry imports in
|
|
`scripts/lib/module-layers.baseline.json`. Application, composition and the
|
|
adapters import a provider through the entry files it declares in that table
|
|
([decision](docs/adr/architecture/provider-entry-files.md)); a new entry file
|
|
widens the provider's public surface. The baseline may only shrink: a
|
|
change that removes such imports lowers it with
|
|
`node scripts/verify-module-boundaries.mjs --shrink-layer-baseline`.
|
|
|
|
Before retiring an alias or facade, trace runtime registration, dynamic imports,
|
|
JavaScript verifiers, subprocess scripts, and packaged entrypoints as well as
|
|
TypeScript references. Tests may be the last consumers of a superseded internal
|
|
path; migrate their distinct assertions to the current production path before
|
|
removing it. Preserve validation, lazy loading, caller policy, and resource
|
|
acquisition and cleanup supplied by the old boundary. Published APIs, persisted
|
|
formats, and independently versioned bridges require an explicit compatibility
|
|
decision; an internal representation alone does not establish that obligation.
|
|
See [interpreting boundary facts once](docs/development/tool-design.md#interpret-boundary-facts-once)
|
|
for admission ownership and the distinction between repeated validation and
|
|
independent checks.
|
|
|
|
For analysis workflows and agent interfaces, follow the
|
|
[performance priorities](AGENTS.md#performance). Explain the selected output
|
|
scope, reuse/cache decisions, and relevant before/after measurements when these
|
|
costs change.
|
|
Use the [analysis optimization skill](.agents/skills/rea-analysis-optimization/SKILL.md)
|
|
to locate provider and shared-workflow bottlenecks, preserve Evidence, and
|
|
compare equivalent real tasks before claiming an improvement.
|
|
|
|
When adding or changing an MCP tool, follow the [tool design guide](docs/development/tool-design.md) and preserve the canonical contracts and generated catalog.
|
|
When adding or changing an admission ceiling, budget, or deadline, follow
|
|
[analysis settings, limits, and recovery](docs/design/limits-and-recovery.md)
|
|
for ownership, operation snapshots, provider integration, and the steps for
|
|
adding a runtime setting.
|
|
|
|
## Reporting issues
|
|
|
|
Use the issue form that fits the report and keep it concise. For bugs, include
|
|
the actual result, the shortest reproduction you ran, the tested version and
|
|
environment, and the smallest useful output, artifact, screenshot, or source
|
|
reference. Ground expected behavior in documentation, source, or a known-good
|
|
version when available. State observed impact and frequency; keep untested scope
|
|
and suspected causes explicit.
|
|
|
|
Incomplete reports and intermittent failures are welcome. If a narrative answer
|
|
or supporting evidence is unavailable, write `NOT_ENOUGH_INFO` and explain the
|
|
gap. Clearly label source-only findings and proposed checks; do not claim runtime
|
|
reproduction or results you did not observe. A root-cause analysis or fix is not
|
|
required to report a problem. Documentation reports should identify the relevant
|
|
passage or missing guidance and explain the correction or confusion.
|
|
|
|
Feature and design proposals can start with a problem and desired outcome.
|
|
Examples, prior art, and measurements help when available; ideas without them
|
|
are welcome. Maintainers can investigate reports and help resolve open questions.
|
|
Human ownership and readiness declarations apply to PRs as described below.
|
|
|
|
## Pull request ownership and readiness
|
|
|
|
AI-assisted contributions are welcome. Every PR must have a human owner who
|
|
takes responsibility for the complete change, including code, tests,
|
|
documentation, and claims produced with AI assistance. The PR author is the
|
|
owner unless another human is named in the PR and explicitly accepts ownership.
|
|
These requirements also apply to maintainer-authored PRs.
|
|
|
|
Before requesting maintainer review, the human owner must:
|
|
|
|
- Review the final diff and relevant existing code. Be able to explain the
|
|
problem, the chosen approach, how it fits REA, and meaningful edge cases.
|
|
- Provide evidence that the change works. Summarize what was checked, the
|
|
observed results, and meaningful gaps in the PR body. Use focused tests,
|
|
representative CLI/MCP output, CI artifacts, screenshots, or other checks
|
|
appropriate to the change. For fixes, show the original failure and why the
|
|
regression coverage catches it when practical. Documentation-only changes
|
|
can use source, link, or rendered-document checks. Label source-derived
|
|
conclusions and proposed checks accurately; never report an unrun check as
|
|
passing. Follow the [verification requirements](#development-feedback-and-pr-verification)
|
|
for required checks and real-provider coverage.
|
|
- Complete the **Author readiness** declaration in the PR template, explicitly
|
|
stating that the PR is ready for initial review, unless the PR author is
|
|
exempt from the declaration as listed below.
|
|
|
|
Keep the PR description concise and current. Explain the problem, observable
|
|
outcome, approach, and useful evidence; link long logs or put them in optional
|
|
details. Address actionable automated review findings and explain disagreements.
|
|
Human ownership and review remain required when CI or an automated reviewer
|
|
reports success. Readiness requests maintainer review; it does not grant scope
|
|
approval or permission to merge.
|
|
|
|
Draft status is optional. Draft PRs may request early feedback with open questions
|
|
and incomplete checks. Agents preserve the current draft status unless asked to
|
|
change it; missing readiness declarations or later updates do not require a PR
|
|
to become a draft.
|
|
|
|
Leave the readiness declaration unchecked until the human owner has completed
|
|
it. The declaration records initial readiness; later pushes do not invalidate
|
|
it or require another human sign-off. Keep the PR description and affected
|
|
validation current as work changes. AI agents must leave human declarations to
|
|
the human owner and must not attest to a human review on their behalf.
|
|
|
|
The `PR readiness` check reports pending for drafts and requires a named human
|
|
owner and all three template declarations for non-drafts. PRs authored by
|
|
@morluto, @kaoru0822-kitauji, @N0zoM1z0, or @gensokyo-dev are exempt from
|
|
the declaration; their human ownership, review, and evidence responsibilities
|
|
above still apply. The check identifies authors by GitHub account ID. It checks
|
|
that the declaration is filled, not whether the code or evidence is correct.
|
|
Existing PRs can copy the **Author readiness** section from the current template.
|
|
Open PRs must have distinct head commits because GitHub shares commit statuses.
|
|
|
|
Maintainers enable merge enforcement after the workflow is merged: run
|
|
`gh workflow run pr-readiness.yml -f pull_request_number=NUMBER` for existing
|
|
open PRs, then add `PR readiness` from GitHub Actions to the branch's required
|
|
status checks alongside its existing checks. Deploy the workflow to each
|
|
protected target branch before requiring it there. The workflow reads PR
|
|
metadata using trusted default-branch code and writes only a commit status.
|
|
|
|
When an open PR may overlap another open change or a recently landed fix, note
|
|
the related PR, issue, or commit in the description or a comment as soon as the
|
|
overlap is known. Prefer one clear pointer over repeated status updates.
|
|
|
|
If an overlapping change merges while a PR awaits review, link that commit on
|
|
the open PR and state what remains useful. Rebase or otherwise align with the
|
|
current base when the remaining work is still wanted, narrow the PR to the
|
|
uncovered portion, or close it when the change is fully superseded. Keep the
|
|
description and validation current after that update. Maintainers may also note
|
|
the expected disposition (rebase, narrow, or close) when they land or recognize
|
|
an overlapping fix. Readiness still does not grant merge permission or a review
|
|
date.
|
|
|
|
Maintainers may return a PR to the author or close it when the problem is
|
|
unsupported, validation is missing, or the owner cannot explain the change.
|
|
Contributors are responsible for completing this work before requesting review.
|
|
|
|
## Contribution scope
|
|
|
|
REA focuses on software structure, runtime behavior, and evidence through
|
|
general-purpose reverse-engineering workflows. Evaluate a proposal by its actual
|
|
capabilities, side effects, defaults, and complete workflow. A tool name or a
|
|
reference to vulnerability research, malware analysis, or CTFs does not determine
|
|
whether it belongs in REA.
|
|
|
|
Supported contributions include format inspection, ordinary archive and standard
|
|
compression extraction, disassembly, decompilation, cross-references, general
|
|
static deobfuscation, vulnerability analysis, and evidence reporting. Static
|
|
protection detection is distinct from defeating that protection. Security fixes
|
|
and isolated regression tests remain in scope.
|
|
|
|
Runtime investigation needs explicit boundaries. Launching or attaching to a
|
|
process, injecting instrumentation, running scripts, and changing memory or
|
|
registers require review of target selection, execution and mutation authority,
|
|
provenance, resource limits, cancellation, and cleanup. General Frida or debugger
|
|
support is not inherently read-only, and existing support does not authorize
|
|
every workflow built on it. General-purpose interfaces are not classified as
|
|
dedicated bypass workflows solely because caller-provided code could be misused;
|
|
their execution and mutation authority must still be reviewed.
|
|
|
|
REA does not integrate or officially distribute:
|
|
|
|
- Purpose-built workflows to defeat commercial packing or code-virtualization
|
|
protections and automatically recover protected code.
|
|
- Anti-debugging or anti-instrumentation evasion, or DRM, license, anti-cheat, or
|
|
access-control bypass workflows.
|
|
- Exploit or attack-payload automation, credential theft, covert persistence,
|
|
unauthorized access, or bulk attack workflows.
|
|
|
|
These boundaries apply to first-party providers, adapters, plugins, bundled
|
|
scripts, defaults, examples, and documentation. Moving a capability into an
|
|
optional dependency or plugin does not exempt it. Review what the integration
|
|
exposes, including upstream defaults and raw-command or script execution paths.
|
|
Ordinary extraction and general static deobfuscation are not excluded merely
|
|
because the input is packed or obfuscated; assess added bypass or execution
|
|
behavior separately.
|
|
|
|
This is a product and maintenance boundary, not a judgment about a contributor's
|
|
intentions or a declaration that all excluded research is unlawful. Contributors
|
|
must have the rights and authorization needed for their work. A local-only design
|
|
or an "authorized use only" disclaimer does not establish containment or settle
|
|
legal and scope questions.
|
|
|
|
### Fail-closed integration
|
|
|
|
If scope fit, target or authorization boundaries, side effects, or the verification
|
|
needed to establish those boundaries remain materially unresolved, **do not merge,
|
|
enable, or include the capability in official packages or distributions**. Keep
|
|
the proposal pending, narrow it, or decline it. Record unknowns explicitly; do not
|
|
turn them into "none" or assumed safety. Passing CI, completed implementation,
|
|
upstream popularity, or silence from maintainers is not scope approval.
|
|
|
|
For a new provider or a capability involving target execution, injection,
|
|
mutation, or protection recovery, seek an explicit maintainer scope decision in
|
|
the linked issue or design discussion before substantial implementation intended
|
|
for integration. Small exploratory prototypes and draft PRs may help inform that
|
|
decision; they do not authorize integration. The decision must cover the final
|
|
proposed behavior; a scope expansion needs a new decision. Routine fixes and
|
|
documentation changes within existing boundaries do not need a separate advance
|
|
decision, but must not silently expand those boundaries.
|
|
|
|
### Starting a proposal
|
|
|
|
To open a feature request or design discussion, describe the problem and desired
|
|
outcome or decision. Short answers and the forms' "Not sure yet" options are
|
|
welcome. You do not need code, a complete design or test plan, legal analysis, or
|
|
private proof-of-authorization documents to start a discussion. Share what you
|
|
know and leave optional details blank when you need help.
|
|
|
|
Form selections guide triage; they are not proof of authorization or scope
|
|
approval. Unselected effects must not be treated as established absence.
|
|
Maintainers and implementers work together to resolve the following before
|
|
integration:
|
|
|
|
- The concrete analyst question, requested inputs and outputs, and why existing
|
|
REA operations are insufficient.
|
|
- Why the workflow fits this scope, its non-goals, and any protection recovery,
|
|
bypass, or attack automation it would expose.
|
|
- The selected targets and every execution, injection, mutation, network, or
|
|
persistence effect, including behavior inherited from upstream tools.
|
|
- How the boundaries and outcome will be verified with self-owned or appropriately
|
|
licensed samples; identify real CLI/MCP and provider coverage, cleanup and
|
|
resource checks, and remaining unknowns. Do not publish private binaries,
|
|
credentials, or sensitive target data; follow [SECURITY.md](SECURITY.md) for
|
|
private vulnerability reports.
|
|
|
|
Mixed proposals should separate acceptable analysis capabilities from excluded
|
|
workflows so each can be decided independently. An issue may discuss unresolved
|
|
questions; opening an issue or PR does not authorize integration. This is a
|
|
maintainer integration gate, not a per-call confirmation requirement or a sandbox
|
|
guarantee.
|
|
|
|
## Development setup
|
|
|
|
Use the development toolchain pinned in `.nvmrc` and
|
|
`package.json#packageManager`. Run `nvm use` before installing dependencies;
|
|
installed-package runtime support is documented in
|
|
[installation](docs/getting-started/installation.md#start-setup).
|
|
Use Node.js and npm for source builds and verifier scripts; the installed
|
|
package's Bun runtime support does not extend to those development scripts.
|
|
|
|
```bash
|
|
npm ci
|
|
npm run check:fast
|
|
```
|
|
|
|
`npm ci` installs the exact dependencies and prepares the Husky hooks without
|
|
building the project. Run `npm run build:cached` when you need the standalone
|
|
CLI or MCP server; it compiles the runtime and bundles the authored skill.
|
|
`npm run build` forces those tasks to rerun. Neither command generates test
|
|
catalogs, documentation projections, or managed verification evidence. Turbo
|
|
caches deterministic builds and static checks across Git worktrees. After a package, lockfile, or managed-skill version change, run
|
|
`npm run metadata:generate` before building.
|
|
|
|
Dependabot proposes updates for the npm lockfiles, website Python requirements,
|
|
and GitHub Actions. Review dependency changes and run the checks relevant to
|
|
their consumers. For dependencies maintained outside Dependabot, including
|
|
`third_party/` and the HTTP/3 lab's pinned requirements, the maintainer should
|
|
review upstream security advisories when updating or using them. Preserve source
|
|
and version provenance, update license notices when needed, and report which
|
|
verification was actually repeated. The lab requirements describe a recorded
|
|
environment; a dependency update does not verify the revised environment.
|
|
|
|
Commits that only move files or rewrite import paths are listed in
|
|
`.git-blame-ignore-revs`; run
|
|
`git config blame.ignoreRevsFile .git-blame-ignore-revs` once so `git blame`
|
|
attributes lines to the change that wrote them. Move files with `git mv` and
|
|
keep such a commit free of other edits.
|
|
|
|
Repository invariants live in [AGENTS.md](AGENTS.md). Keep provider-specific
|
|
protocols in adapters and shared CLI/MCP workflows in the application layer.
|
|
|
|
### Windows source checkouts
|
|
|
|
The published npm package includes the Windows x64 native addon and its
|
|
manifest. A source checkout does not: `native/windows/build/` is ignored by
|
|
Git, and neither `npm ci` nor `npm run build:cached` (or `npm run build`)
|
|
produces `rea-windows-x64.node` or `manifest.json` in that directory.
|
|
Windows workflows and tests that require native controls need these artifacts;
|
|
this includes `run-exclusive` commands, which use the native Job Object to keep
|
|
the artifact lock until every command descendant has exited. Without the
|
|
artifacts, those controls are unavailable even after a successful runtime
|
|
build.
|
|
|
|
Follow the [Windows native build guide](native/windows/README.md#build) before
|
|
running those workflows from source. The artifact build requires Linux,
|
|
MinGW-w64, and `tar`; the build script does not run on Windows. See that guide
|
|
for the build and artifact-verification commands and the separate real Windows
|
|
verification prerequisites. Keep the generated addon and manifest uncommitted.
|
|
|
|
The general source suite (`npm run test:fast`, `npm run test:changed`, and
|
|
`npm run test:local`) runs on Linux in CI, and Windows CI runs a curated lane.
|
|
On a Windows checkout, some source tests fail because fixtures use POSIX paths,
|
|
`#!/bin/sh` tool stubs, or POSIX rename semantics. Compare failures against the
|
|
base revision, or run the suite on Linux or WSL, before attributing them to a
|
|
change. The embedded-artifact parent-swap tests exercise the selected-path
|
|
replacement when the rename succeeds; if Windows refuses it while the admitted
|
|
file is open, they instead verify the refusal and cleanup. See
|
|
[testing](docs/development/testing.md#developer-commands) for command scopes
|
|
and lane selection.
|
|
|
|
`git submodule update --init --recursive` fails at the pinned Unblob submodule
|
|
on Windows and can leave later submodules unchecked out. Apply the
|
|
[Unblob checkout workaround](docs/guides/firmware/firmware-analysis.md#windows-submodule-checkout),
|
|
then rerun the command.
|
|
|
|
## Documentation website
|
|
|
|
Use the [documentation directory](docs/README.md) and
|
|
[authoring guide](docs/development/documentation.md) for document ownership,
|
|
domain-based feature specifications and architectural decision records.
|
|
|
|
The VitePress site uses the Markdown files in `docs/`. Run `npm run docs:dev`
|
|
for live editing, `npm run docs:build` to check the production build and
|
|
links, and `npm run docs:preview` to preview that build at `/rea/`.
|
|
|
|
Site navigation lives in `docs/.vitepress/config.ts`. Keep links to guides
|
|
relative so they work on GitHub and the website; link to repository files
|
|
outside `docs/` using their full GitHub URLs. Generated reference documents
|
|
use `npm run docs:generate`; `docs:build` generates them before building the website.
|
|
|
|
Pull requests run `npm run docs:check`. `.github/workflows/pages.yml` is a
|
|
manual VitePress build and does not publish. The public site at
|
|
<https://rea.tools/> serves `website/public/` through Cloudflare Workers. See
|
|
the [website README](website/README.md#cloudflare-workers) for previews and
|
|
manual deployments.
|
|
|
|
The separate GitHub Pages host uses only the manual
|
|
`.github/workflows/website-pages.yml` workflow on `main`. The repository's
|
|
**Settings → Pages → Build and deployment → Source** must be set to
|
|
**GitHub Actions** before deploying there.
|
|
|
|
### Translation corrections
|
|
|
|
README editions and website editions have separate translation sources:
|
|
|
|
- Find the language's `readme` path in the
|
|
[language inventory](website/locales/languages.json) and edit that file.
|
|
Locale codes and README suffixes can differ. Use the
|
|
[English README](README.md) to check commands, requirements, and analysis claims.
|
|
- Edit `msgstr` values in `website/locales/<language>/messages.po` for website
|
|
text. Follow the [website translation guide](website/locales/README.md) for
|
|
the Python environment, catalog validation, and local preview. Preserve source
|
|
strings, contexts, placeholders, commands, paths, and recorded evidence.
|
|
|
|
Before submitting a website translation, run the catalog and website checks in
|
|
that guide. Translated HTML in `website/_site/` is generated; edit the PO catalog
|
|
rather than the generated pages.
|
|
|
|
## Development feedback and PR verification
|
|
|
|
For routine merges, wait for the required checks to pass for the current PR
|
|
revision. Administrators retain an override for deliberate maintainer recovery.
|
|
If `main` is broken, prioritize a focused repair before updating affected PRs.
|
|
|
|
Select checks for the behavior changed. For a source edit:
|
|
|
|
```bash
|
|
npm run test:focused -- src/config.test.ts
|
|
npm run check:fast
|
|
```
|
|
|
|
`test:local` runs source tests without building. `check:changed` combines cached
|
|
static checks with source tests affected since the merge base with `origin/main`.
|
|
Import-graph selection can miss runtime registration, bridges, and generated data;
|
|
select relevant boundary tests explicitly. See [testing](docs/development/testing.md#developer-commands)
|
|
for commands, test placement, pruning, and real-provider prerequisites.
|
|
|
|
Before requesting review, run relevant tests and `npm run check`; add
|
|
`npm run docs:check` when contracts or generated metadata change. Record the
|
|
checks and unavailable coverage. CI owns the full deterministic suite and
|
|
coverage. `npm run check:pr` is an optional full local gate for broad changes or
|
|
CI diagnosis. Packaging/setup/distribution changes additionally require
|
|
`npm run verify:package` and `npm pack --dry-run`; provider changes require the
|
|
matching real-provider lane. State which host/provider workflows ran.
|
|
|
|
For CI/test correctness, drift, or performance investigations, use the
|
|
[`rea-ci-tests-audit` contributor skill](.agents/skills/rea-ci-tests-audit/SKILL.md).
|
|
It guides reproduction and comparable measurements before changing checks.
|
|
|
|
`check:pr` reuses build and static-check outputs while executing the test suite
|
|
fresh, including the fast Python producer checks. `docs:check` also runs the
|
|
onboarding example consistency suite for README-only changes.
|
|
|
|
Pre-commit formats and lints staged files; pre-push runs `check:fast`.
|
|
|
|
### Generated files and command ownership
|
|
|
|
`docs:generate` prepares documentation and portable managed evidence;
|
|
`evidence:generate` prepares only the managed commitment and its runtime/skill
|
|
dependencies. The ignored outputs are `docs/public/product-catalog.json`,
|
|
`docs/verification/managed-conformance-*.json`, and `skills/`. Edit authored
|
|
skill instructions in `.agents/skills/reverse-engineer-anything/`, where Skills
|
|
can discover the public bundle directly from a clean checkout. `verify:package`
|
|
installs that bundle with Skills 1.7.2 using default repository-root discovery
|
|
and checks every installed file, alongside the packaged setup checks.
|
|
CI validates generated outputs and retains them as artifacts; do not commit
|
|
them. Reviewed source metadata, including
|
|
`src/generatedPackageMetadata.ts`, `docs/error-contract.schema.json` and
|
|
`docs/user-visible-errors.csv`, remains tracked and checked for freshness.
|
|
|
|
The packaged skill contains instructions and inventory metadata, not runtime
|
|
schema hashes. Its conformance commitment covers that exact bundle and portable
|
|
verification; it does not attest optional real-provider runs. Schema-only changes
|
|
should not alter that commitment. Doctor and `binary_session` expose runtime
|
|
schema identity.
|
|
|
|
Build/generation commands hold a SQLite transaction around the entire Turbo
|
|
graph, including cache restoration. `.cache/rea-command-locks/` databases identify
|
|
locks, not stale files; never remove them while commands run. POSIX cancellation
|
|
retains process-group ownership until settlement; Windows waits for completion.
|
|
Real-provider execution is uncached.
|
|
|
|
### Temporary files and diagnostics
|
|
|
|
Tests use `createTestTempDirectory` from `tests/fixtures/temporaryDirectory.ts`
|
|
for exact-path, awaited cleanup, including failures and timeouts. It registers
|
|
deletion with Vitest's `onTestFinished`; do not also add its result to a roots
|
|
array or an `afterEach` removal. `createTestWorkspace` from
|
|
`tests/support/workspace/workspaceFixture.ts` leaves cleanup with its caller,
|
|
which must await `removeTestWorkspace`. Keep explicit resource teardown before
|
|
directory deletion, using the case's `finally` or `afterEach`; Vitest runs
|
|
`afterEach` before `onTestFinished` and awaits finish hooks in reverse
|
|
registration order.
|
|
`npm run verify:test-temp-hygiene` runs the suite under a fresh `TMPDIR` and
|
|
rejects remaining REA-owned paths. It cannot detect duplicate deletion owners or
|
|
prove resource-close ordering. Never glob-clean shared `/tmp/rea-*` content.
|
|
|
|
`REA_LOG_LEVEL` selects `trace`, `debug`, `info`, `warn`, `error`, `fatal`, or
|
|
`silent`. Logs go to stderr: MCP defaults to `info`, and one-shot CLI logging
|
|
is opt-in, so stdout carries only protocol messages and command results.
|
|
Request arguments, bridge tokens, and environment data are redacted from
|
|
diagnostic logs.
|
|
|
|
## Real Hopper changes
|
|
|
|
Run `npm run verify:hopper` on a supported macOS host or
|
|
`npm run verify:hopper:linux` on the supported Linux demo runner. These build
|
|
native fixtures and verify the installed engine through CLI/MCP; package or
|
|
simulated-provider checks do not establish engine behavior. See
|
|
[real-toolchain verification](docs/development/testing.md#end-to-end-integration-and-golden-evidence)
|
|
for prerequisites and scope, and [Hopper setup](docs/getting-started/installation.md#hopper)
|
|
for supported hosts and unattended startup.
|
|
|
|
Use the default `build/conformance/manifest.json` unless explicitly verifying
|
|
another source-built manifest with `REA_HOPPER_CONFORMANCE_MANIFEST_PATH`.
|
|
Generated fixtures and manifests remain ignored.
|
|
|
|
## Maintainer release checklist
|
|
|
|
Use the [release guide](docs/development/releasing.md). Main pushes automatically refresh a
|
|
Release Please PR with the next version and changelog. Review its migration
|
|
notes, wait for the current CI checks to pass, and merge it into main to publish.
|
|
|
|
The Release workflow validates and tags that merge; both publishers build its
|
|
exact SHA. Ordinary main pushes cannot publish packages. An optional manual
|
|
`release/VERSION` checkpoint retains explicit preparation and publication.
|
|
|
|
For grouped release notes with verified contributor thanks, use the repository's
|
|
`rea-changelog-update` skill in `.agents/skills/rea-changelog-update/`. Its inventory,
|
|
credit checks, and finalization process are described in the release guide.
|
|
|
|
Keep new implementation commits on main for the next release. The workflow
|
|
owns packaged-artifact verification, npm publication, the published CLI/MCP
|
|
canary, and MCP Registry publication. Sync manual checkpoint metadata back to
|
|
main after publication; see the guide for recovery and verification.
|