rea-agents 5.0.0 → 6.1.0

package/third_party/evmole/README.md

@@ -0,0 +1,22 @@
+# EVM interface upstream profile
+
+REA integrates unchanged [EVMole](https://github.com/cdump/evmole) as the exact
+npm dependency `evmole@0.9.3`, with lockfile integrity verification. Tag `0.9.3`
+resolves to commit `0409707c2efef11a9043f9b4505cad5719054a7e`.
+
+The JavaScript binding and WASM engine remain in the original upstream package;
+REA contains only carrier validation, a worker adapter and portable contracts.
+No submodule or vendored engine fork is required. No signature database,
+LLM decompiler, blockchain node or RPC dependency is acquired.
+
+Upstream is MIT, copyright (c) 2023 Maxim Andreev. Its npm tarball omits the
+license file, so REA packages the unchanged tag's [LICENSE](LICENSE) here.
+The engine is initialized through the upstream `no_tla`/`initSync` interface
+only inside an owned worker; importing REA services performs no WASM/file I/O.
+
+Initial interface analysis uses `contractInfo` with selectors, arguments and
+stateMutability enabled. Selector recovery also extracts/reports terminal metadata;
+its reported representation is retained with explicit unknown precision/coverage.
+Other upstream outputs are separate future contracts;
+in particular, CFG destination IDs are not byte addresses and terminal CBOR
+metadata cannot establish a lossless integer claim through the current binding.

package/third_party/pwndbg/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Dominik 'Disconnect3d' Czarnota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/third_party/pwndbg/README.md

@@ -0,0 +1,23 @@
+# pwndbg core context adapter
+
+REA uses caller-supplied unchanged [pwndbg](https://github.com/pwndbg/pwndbg)
+2026.09.15, commit `55596aa676a2756efb8d67034f31675170eabe48`, and GDB.
+The original MIT license is retained in `LICENSE.md`. Engine source and its
+dependencies are not vendored or acquired by REA.
+
+The adapter executes the selected upstream `gdbinit.py` with its original
+`__file__`, an explicitly selected existing virtual environment, and
+`PWNDBG_NO_AUTOUPDATE=1`. The upstream entrypoint and dependencies are trusted
+caller-supplied executable code. Reported versions establish observed behavior,
+not source authenticity. The real verification lane checks out the exact commit
+and uses its frozen `uv.lock` in isolated runner storage.
+
+Only `pwndbg.aglib.vmmap.get()` is queried, after establishing a core-only GDB
+connection without an executable. All original core notes and recorded register
+values come from the independent pwntools/pyelftools decoder. Mapping candidates
+are derived; original pathnames do not identify current host files, and reported
+flags zero leave permissions unknown. REA does not expose upstream command
+execution, live attach, target launch, implicit executable pairing or updates.
+
+Local actual verification uses Linux x64, GDB 13.1 and the exact upstream tag/build.
+Other GDB versions require their corresponding real workflow before being claimed.

package/third_party/pwntools/README.md

@@ -0,0 +1,40 @@
+# Offline ELF upstream profile
+
+REA uses caller-supplied, unchanged Python packages. It vendors no pwntools,
+pyelftools or Unicorn implementation and never installs these dependencies.
+
+| Upstream | Exact verified profile | License | Role |
+| --- | --- | --- | --- |
+| [pwntools](https://github.com/Gallopsled/pwntools) | 4.15.0; tag commit `3ad86ec5adab1abf9781ca7552a6f5d7cff7a33c` | MIT | ELF analysis and static mitigation/GOT/PLT heuristics |
+| [pyelftools](https://github.com/eliben/pyelftools) | 0.33 | Public domain | Original ELF sections, segments, symbols and relocations |
+| [Unicorn](https://github.com/unicorn-engine/unicorn) | 2.1.2 | GPL-2.0 | Upstream PLT emulation; distinct from executing the target as a host process |
+
+The adapter checks all three runtime versions before importing the ELF engine.
+Original upstream code/licenses remain in the caller-selected environment.
+No target or core binaries are committed. Fixtures are compiled in owned
+temporary storage from repository source and are never executed.
+
+`bridge/pwntools/layout.py` is an owned allocation-failure bootstrap;
+`layout_impl.py` is the adapter. It reads original tables through
+unchanged upstream APIs, preserves raw name bytes/ranges, and serializes uint64
+values as strings. It never accesses `ELF.libs`, `ELF.maps`, `ELF.libc` or
+`process.corefile`, which have materially different execution authority.
+
+The real verification lane traces host exec syscalls, checks original artifact
+hashes and observes released owned processes. No negative claim relies only on
+an unmodified target's sentinel: upstream can execute a patched copy when its
+runtime-library accessors are used.
+
+The instance-local adapter subclass forwards the documented pyelftools 0.33
+`iter_segments(type=...)` / `iter_sections(type=...)` filters missing from
+pwntools 4.15.0 cached overrides. No upstream file or global method is changed.
+Sectionless dynamic string tables use unique DT_STRTAB/DT_STRSZ mappings to
+file-backed PT_LOAD bytes; ambiguous or non-file-backed mappings are explicitly
+unsupported. Section-name table escapes follow the [ELF ABI](https://gabi.xinuos.com/elf/02-eheader.html):
+SHN_XINDEX represents actual indices at least 0xff00; ordinary absence uses index
+zero. Raw name offsets remain reported when the name table is absent.
+
+PLT convenience inference uses the unchanged upstream Unicorn instruction
+emulator. REA labels those maps as derived static evidence. The no-execution
+verification claim concerns launching the selected object as a host process,
+not the absence of static instruction emulation inside an analysis engine.

package/dist/application/AuthorizedArtifactInventory.js

@@ -1,7 +0,0 @@
-import { realpath } from "node:fs/promises";
-import { scanCanonicalArtifactInventory, } from "./ArtifactInventory.js";
-/** Resolve, authorize, and scan one artifact without a second path resolution. */
-export const scanAuthorizedArtifactInventory = async (inputPath, options = {}) => {
-    const path = await realpath(inputPath);
-    return scanCanonicalArtifactInventory(path, options);
-};

package/dist/application/ProcessCaptureLifecycle.js

@@ -1,299 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { digestProcessCommitment, processComparisonContract, processScenarioCommitment, } from "../domain/processCapture.js";
-import { PRODUCT_IDENTITY } from "../identity.js";
-import { snapshotRoots } from "./FilesystemSnapshot.js";
-import { classifyFilesystemEffects } from "./ProcessFilesystemEffects.js";
-import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
-import { observeOwnedProcessGroup } from "../process/ProcessOwnershipObservation.js";
-import { ProcessCaptureError } from "./ProcessCaptureError.js";
-import { assertNotCancelled } from "./ProcessScenarioRuntimeValidation.js";
-import { normalizeProcessElapsedTime, normalizeProcessSamples, normalizeProcessText, } from "./ProcessNormalization.js";
-import { PROCESS_PROVIDER } from "./ProcessEvidence.js";
-import { TerminalRenderer } from "./TerminalRenderer.js";
-import { scheduleProcessInterval } from "./ProcessTimer.js";
-/** Wait for trailing PTY callbacks before the capture becomes immutable. */
-export const settleProcessCaptureJournal = async (journal, quietMs = 25, maxWaitMs = 500) => {
-    const deadline = Date.now() + maxWaitMs;
-    let observed = journal.length;
-    let lastChangeAt = Date.now();
-    while (Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, 4));
-        if (journal.length !== observed) {
-            observed = journal.length;
-            lastChangeAt = Date.now();
-        }
-        else if (Date.now() - lastChangeAt >= quietMs)
-            return;
-    }
-};
-export const buildCaptureResult = (options) => {
-    const hasSensitiveScriptedInput = options.scenario.events.some((event) => event.type === "input" && event.sensitive);
-    const sensitiveInputUnknown = "Sensitive scripted input values are redacted from process capture Evidence.";
-    const filesystemObservationUnknown = "No filesystem observation paths were selected; filesystem effects remain unknown.";
-    const hasFilesystemObservations = options.scenario.filesystem_observation_paths.length > 0;
-    return {
-        manifest: options.manifest,
-        normalization: options.scenario.normalization,
-        frames: options.frames,
-        rendered_frames: options.renderedFrames,
-        interaction_events: options.interactions,
-        exit: {
-            code: options.exit.reason === "exited" && options.exit.exitCode >= 0
-                ? options.exit.exitCode
-                : null,
-            signal: options.exit.signal ?? null,
-            reason: options.exit.reason,
-        },
-        settlement: options.settlement,
-        process_samples: normalizeProcessSamples(options.samples, options.scenario, options.rootPid),
-        filesystem_checkpoints: options.checkpoints,
-        event_journal: options.eventJournal,
-        files_before: options.before.files,
-        files_after: options.after.files,
-        filesystem_effects: classifyFilesystemEffects(options.before.files, options.after.files),
-        truncated: options.truncated,
-        limitations: [
-            "Process trees are sampled and may omit short-lived descendants.",
-            ...(options.samplingPartial
-                ? ["Process-tree sampling ended with an incomplete observation."]
-                : []),
-            "Filesystem observations are before/after snapshots, not syscall traces.",
-            "Inherited host environment variables are not recorded and may affect results.",
-            ...(!hasFilesystemObservations ? [filesystemObservationUnknown] : []),
-            ...(hasSensitiveScriptedInput ? [sensitiveInputUnknown] : []),
-        ],
-        residual_unknowns: [
-            {
-                scope: "process",
-                reason: "Process trees are sampled and may omit short-lived descendants.",
-            },
-            {
-                scope: "environment",
-                reason: "Inherited host environment variables are not recorded.",
-            },
-            {
-                scope: "network",
-                reason: "Network activity is not observed by this capture.",
-            },
-            ...(!hasFilesystemObservations
-                ? [
-                    {
-                        scope: "filesystem",
-                        reason: filesystemObservationUnknown,
-                    },
-                ]
-                : []),
-            ...(hasSensitiveScriptedInput
-                ? [{ scope: "interaction", reason: sensitiveInputUnknown }]
-                : []),
-        ],
-    };
-};
-const hashFile = async (path) => {
-    const hash = createHash("sha256");
-    for await (const chunk of createReadStream(path))
-        hash.update(chunk);
-    return hash.digest("hex");
-};
-export const createRunManifest = async (scenario, startedAt, completedAt, host = {
-    platform: process.platform,
-    architecture: process.arch,
-}) => {
-    const executableSha256 = await hashFile(scenario.executable);
-    const scenarioCommitment = processScenarioCommitment(scenario, executableSha256);
-    const comparisonContract = processComparisonContract(scenario);
-    return {
-        rea_version: PRODUCT_IDENTITY.packageVersion,
-        provider_version: PROCESS_PROVIDER.version,
-        platform: host.platform,
-        architecture: host.architecture,
-        pty_backend: "node-pty",
-        started_at: startedAt.toISOString(),
-        completed_at: completedAt.toISOString(),
-        scenario: scenarioCommitment,
-        comparison_contract: comparisonContract,
-        full_scenario_sha256: digestProcessCommitment(scenarioCommitment),
-        comparison_contract_sha256: digestProcessCommitment(comparisonContract),
-        executable_sha256: executableSha256,
-        normalization_sha256: digestProcessCommitment(scenario.normalization),
-    };
-};
-export const observeSettlement = async (runId, processGroupIds, settleMs, recordEvent = () => undefined, platform = process.platform) => {
-    if (platform === "win32") {
-        recordEvent("lifecycle", 1);
-        return { state: "unverifiable", elapsed_ms: 0 };
-    }
-    const started = Date.now();
-    let consecutiveEmpty = 0;
-    let deadlineReached = false;
-    while (!deadlineReached) {
-        const observations = await Promise.all([...new Set(processGroupIds)].map((processGroupId) => observeOwnedProcessGroup({
-            runId,
-            leaderPid: processGroupId,
-            processGroupId,
-        })));
-        if (observations.some(({ state }) => state === "unverifiable")) {
-            recordEvent("lifecycle", 1);
-            return { state: "unverifiable", elapsed_ms: Date.now() - started };
-        }
-        if (observations.every(({ state }) => state === "empty")) {
-            consecutiveEmpty += 1;
-            if (consecutiveEmpty >= 2) {
-                recordEvent("lifecycle", 1);
-                return { state: "quiesced", elapsed_ms: Date.now() - started };
-            }
-        }
-        else
-            consecutiveEmpty = 0;
-        deadlineReached = Date.now() - started >= settleMs;
-        if (deadlineReached)
-            break;
-        await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-    recordEvent("lifecycle", 1);
-    return { state: "alive_at_deadline", elapsed_ms: Date.now() - started };
-};
-export const awaitTerminalExit = async ({ terminal, scenario, started, lastOutput, signal, timers, interactions, dispatchedEventIndexes, recordEvent, }) => new Promise((resolveExit) => {
-    // The kill caused by a deadline is observed later as an ordinary PTY exit.
-    // Keep the initiating lifecycle reason so comparisons distinguish a target
-    // exit from harness-owned timeout, idle-timeout, and cancellation cleanup.
-    let reason = "exited";
-    terminal.onExit((exit) => {
-        recordEvent("lifecycle", 0);
-        for (const [eventIndex, event] of scenario.events.entries()) {
-            if (dispatchedEventIndexes.has(eventIndex))
-                continue;
-            const sequence = interactions.length;
-            interactions.push({
-                sequence,
-                scheduled_at_ms: event.at_ms,
-                dispatched_at_ms: Math.max(0, Date.now() - started),
-                type: event.type,
-                data: event.type === "input"
-                    ? "<not-dispatched>"
-                    : event.type === "resize"
-                        ? `${String(event.columns)}x${String(event.rows)}`
-                        : event.signal,
-                outcome: "target_exited",
-            });
-            recordEvent("interaction_events", sequence);
-        }
-        for (const timer of timers) {
-            timer.cancel();
-        }
-        timers.clear();
-        resolveExit({ ...exit, reason });
-    });
-    const timeout = scheduleProcessInterval(() => {
-        if (signal?.aborted === true) {
-            reason = "cancelled";
-            terminal.kill("SIGKILL");
-        }
-        else if (Date.now() - started >= scenario.timeout_ms) {
-            reason = "timeout";
-            terminal.kill("SIGKILL");
-        }
-        else if (Date.now() - lastOutput() >= scenario.idle_timeout_ms) {
-            reason = "idle_timeout";
-            terminal.kill("SIGKILL");
-        }
-    }, 20);
-    timers.add(timeout);
-});
-const processCaptureCleanupHost = {
-    platform: process.platform,
-    cleanupProcessGroup: cleanupOwnedProcessGroup,
-    removeTemporaryRoot: (path) => rm(path, { recursive: true, force: true }),
-};
-export const releaseProcessResources = async (options) => {
-    const host = options.host ?? processCaptureCleanupHost;
-    for (const timer of options.timers)
-        timer.cancel();
-    let failure;
-    try {
-        await options.renderer?.dispose();
-    }
-    catch (cause) {
-        void cause;
-        failure ??= "terminal renderer cleanup failed";
-    }
-    if (options.terminal !== undefined && host.platform !== "win32") {
-        for (const processGroupId of new Set(options.capturedProcessGroupIds)) {
-            const cleaned = await host.cleanupProcessGroup({
-                runId: options.runId,
-                leaderPid: processGroupId,
-                processGroupId,
-            });
-            if (!cleaned.cleaned)
-                failure ??= cleaned.reason;
-        }
-    }
-    try {
-        await host.removeTemporaryRoot(options.temporaryRoot);
-    }
-    catch (cause) {
-        void cause;
-        failure ??= "temporary process root cleanup failed";
-    }
-    return failure;
-};
-export const captureTerminalFrames = (options) => {
-    let outputBytes = 0;
-    let truncated = false;
-    options.terminal.onData((data) => {
-        options.onOutput();
-        const bytes = Buffer.byteLength(data);
-        if (outputBytes + bytes > options.scenario.limits.output_bytes) {
-            truncated = true;
-            return;
-        }
-        outputBytes += bytes;
-        const atMs = normalizeProcessElapsedTime(Date.now() - options.started, options.scenario.normalization.time_bucket_ms);
-        const normalized = normalizeProcessText(data, options.scenario, options.temporaryRoot, options.terminal.pid);
-        const sequence = options.frames.length;
-        options.frames.push({
-            sequence,
-            at_ms: atMs,
-            data: normalized,
-        });
-        options.renderer.write(data, atMs);
-        options.recordEvent("frames", sequence);
-    });
-    return () => truncated;
-};
-export const resolveProcessResult = (capture, executionFailure, cleanupFailure) => {
-    if (executionFailure instanceof ProcessCaptureError)
-        throw executionFailure;
-    if (executionFailure !== undefined)
-        throw new ProcessCaptureError("process capture failed", {
-            cause: executionFailure,
-        });
-    if (cleanupFailure !== undefined)
-        throw new ProcessCaptureError(cleanupFailure, {
-            reason: "cleanup_incomplete",
-        });
-    if (capture === undefined)
-        throw new ProcessCaptureError("process capture produced no result");
-    return capture;
-};
-export const prepareProcessCapture = async (scenario, signal, captureSnapshot = snapshotRoots, host = systemProcessPreparationHost) => {
-    assertNotCancelled(signal);
-    const before = await captureSnapshot(scenario, signal);
-    const temporaryRoot = await host.createTemporaryRoot();
-    try {
-        const runId = randomUUID();
-        return { temporaryRoot, runId, before };
-    }
-    catch (cause) {
-        await host.cleanup(temporaryRoot);
-        throw cause;
-    }
-};
-const systemProcessPreparationHost = {
-    createTemporaryRoot: () => mkdtemp(join(tmpdir(), "rea-process-")),
-    cleanup: (path) => rm(path, { recursive: true, force: true }),
-};

package/dist/application/StoreFileLock.js

@@ -1,124 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { lstat, mkdtemp, open, readdir, rename, rm, rmdir, unlink, } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
-class StoreFileLockOccupied extends Error {
-    code = "EEXIST";
-    constructor(cause) {
-        super("Store transaction lock is occupied", { cause });
-    }
-}
-/** Atomically publish a populated directory so another owner cannot replace a live lock. */
-export const createStoreFileLock = async (path) => {
-    if (await exists(path))
-        throw new StoreFileLockOccupied();
-    const staged = await mkdtemp(join(dirname(path), ".rea-store-lock-"));
-    const owner = `owner-${randomUUID()}`;
-    try {
-        const handle = await open(join(staged, owner), "wx", 0o600);
-        try {
-            await handle.writeFile(`${String(process.pid)}\n`, "utf8");
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        try {
-            // Rename cannot replace a nonempty directory: the owner entry is present before publication.
-            await rename(staged, path);
-        }
-        catch (cause) {
-            if (await exists(path))
-                throw new StoreFileLockOccupied(cause);
-            throw cause;
-        }
-        return {
-            release: async () => {
-                await removeOwner(path, owner).catch((cause) => {
-                    // best-effort cleanup: lock release must not reject unhandled.
-                    void cause;
-                });
-            },
-        };
-    }
-    finally {
-        await rm(staged, { recursive: true, force: true });
-    }
-};
-/** Recover a dead owner's directory lock or a legacy PID file; leave live and unknown owners intact. */
-export const removeStaleStoreFileLock = async (path) => {
-    try {
-        const stats = await lstat(path);
-        if (stats.isFile()) {
-            if (!(await ownerIsDead(path)))
-                return false;
-            await unlink(path);
-            return true;
-        }
-        if (!stats.isDirectory())
-            return false;
-        const entries = await readdir(path);
-        if (entries.length === 0) {
-            await rmdir(path);
-            return true;
-        }
-        const owner = entries[0];
-        if (entries.length !== 1 ||
-            owner === undefined ||
-            !/^owner-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(owner) ||
-            !(await ownerIsDead(join(path, owner))))
-            return false;
-        await removeOwner(path, owner);
-        return true;
-    }
-    catch (cause) {
-        // best-effort cleanup: stale lock probing; failure means the lock stands.
-        void cause;
-        return false;
-    }
-};
-const removeOwner = async (path, owner) => {
-    // A successor has a different entry, so stale cleanup cannot make its directory empty.
-    await unlink(join(path, owner));
-    await rmdir(path);
-};
-const ownerIsDead = async (path) => {
-    const stats = await lstat(path);
-    if (!stats.isFile() || stats.size > 32)
-        return false;
-    const handle = await open(path, "r");
-    let bytes;
-    try {
-        bytes = await readBoundedFileBytes(handle, 32);
-    }
-    finally {
-        await handle.close();
-    }
-    const encoded = bytes?.toString("utf8").trim();
-    return (encoded !== undefined &&
-        /^[1-9][0-9]{0,9}$/u.test(encoded) &&
-        !processIsAlive(Number(encoded)));
-};
-const exists = async (path) => {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (cause) {
-        if (errorCode(cause) === "ENOENT")
-            return false;
-        throw cause;
-    }
-};
-const processIsAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== "ESRCH";
-    }
-};
-const errorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
-    ? cause.code
-    : undefined;

package/dist/contracts/processCaptureExample.js

@@ -1,2 +0,0 @@
-/** Minimal valid process capture retained as a public contract example. */
-export { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../domain/processCaptureExample.js";