rea-agents 4.0.1 → 5.0.0

package/dist/server/runDerivedOperation.js

@@ -1,5 +1,5 @@
 import { setImmediate } from "node:timers/promises";
-import { AnalysisCancelledError, AnalysisInputError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 /** Run synchronous derived work with transport yields and a publication guard. */

package/dist/server/sessionAvailabilityPolicy.js

@@ -1,11 +1,26 @@
 import { platform } from "node:process";
 /** Select configured availability reporting or the target-free defaults. */
-export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
-    (() => ({
-        processCaptureEnabled: platform !== "win32",
-        browserObservationEnabled: defaults.optionalFeatures?.browserObservationEnabled ?? false,
-        browserScenarioEnabled: defaults.optionalFeatures?.browserScenarioEnabled ?? false,
-        electronObservationEnabled: defaults.optionalFeatures?.electronObservationEnabled ?? false,
-        electronAutomationEnabled: defaults.optionalFeatures?.electronAutomationEnabled ?? false,
-        v8InspectorObservationEnabled: defaults.optionalFeatures?.v8InspectorObservationEnabled ?? false,
-    }));
+export const sessionAvailabilityPolicy = (configured, defaults) => {
+    const policy = configured ??
+        (() => ({
+            processCaptureEnabled: platform !== "win32",
+            firmwareInspectionEnabled: defaults.optionalFeatures?.firmwareInspectionEnabled ?? false,
+            firmwareExtractionEnabled: defaults.optionalFeatures?.firmwareExtractionEnabled ?? false,
+            androidAnalysisEnabled: defaults.optionalFeatures?.androidAnalysisEnabled ?? false,
+            javascriptRecoveryEnabled: defaults.optionalFeatures?.javascriptRecoveryEnabled ?? false,
+            webModuleResolutionEnabled: defaults.optionalFeatures?.webModuleResolutionEnabled ?? false,
+            browserObservationEnabled: defaults.optionalFeatures?.browserObservationEnabled ?? false,
+            browserScenarioEnabled: defaults.optionalFeatures?.browserScenarioEnabled ?? false,
+            electronObservationEnabled: defaults.optionalFeatures?.electronObservationEnabled ?? false,
+            electronAutomationEnabled: defaults.optionalFeatures?.electronAutomationEnabled ?? false,
+            v8InspectorObservationEnabled: defaults.optionalFeatures?.v8InspectorObservationEnabled ?? false,
+        }));
+    return () => ({
+        ...policy(),
+        ...(defaults.optionalProviderLoadFailures === undefined
+            ? {}
+            : {
+                optionalProviderLoadFailures: defaults.optionalProviderLoadFailures,
+            }),
+    });
+};

package/dist/server/sessionEvidence.js

@@ -1,4 +1,4 @@
-import { EvidenceIntegrityError } from "../domain/errors.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { ok } from "../domain/result.js";
 /** Record source evidence in order, stopping at the first session rejection. */
 export const recordSessionEvidenceSources = (recordEvidence, sources) => {

package/dist/server/toolResult.js

@@ -1,4 +1,5 @@
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import {} from "../domain/analysisErrorBase.js";
 /**
  * Serialize an application result as MCP text and structured content.
  * Shared error projection preserves actionable local diagnostics while omitting

package/dist/windows/WindowsNativeLoader.js

@@ -0,0 +1,108 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { PACKAGE_METADATA } from "../generatedPackageMetadata.js";
+/** A native resource remains opaque until the addon validates its object tag. */
+export const windowsHandleSchema = z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+/** Observed identity of an opened local NTFS object. */
+export const windowsFileIdentitySchema = z.strictObject({
+    requestedPath: z.string(),
+    finalPath: z.string(),
+    filesystem: z.literal("NTFS"),
+    volumeSerial: z.string().regex(/^[a-f0-9]{16}$/u),
+    fileId: z.string().regex(/^[a-f0-9]{32}$/u),
+    size: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    directory: z.boolean(),
+});
+/** Metadata bound to one packaged Windows x64 Node-API artifact. */
+export const windowsNativeManifestSchema = z.strictObject({
+    packageVersion: z.string(),
+    platform: z.literal("win32"),
+    architecture: z.literal("x64"),
+    abiVersion: z.literal(1),
+    nodeApiVersion: z.literal(8),
+    artifact: z.literal("rea-windows-x64.node"),
+    artifactSha256: z.string().regex(/^[a-f0-9]{64}$/u),
+});
+const inspectionSchema = z.strictObject({
+    abiVersion: z.literal(1),
+    nodeApiVersion: z.literal(8),
+    architecture: z.literal("x64"),
+    filesystem: windowsFileIdentitySchema,
+    privateDacl: z.literal(true),
+    atomicJobAssignment: z.literal(true),
+    killOnOwnerClose: z.literal(true),
+});
+const bindingSchema = z.strictObject({
+    call: z.custom((value) => typeof value === "function"),
+});
+/** Validate compatibility and artifact identity before invoking the native addon. */
+export const loadWindowsNativeAuthority = (host) => {
+    if (host.platform !== "win32" || host.architecture !== "x64")
+        return {
+            available: false,
+            reason: "REA Windows native controls require a Windows x64 host.",
+        };
+    try {
+        const manifest = windowsNativeManifestSchema.parse(host.readManifest());
+        if (manifest.packageVersion !== host.packageVersion)
+            throw new Error("Windows native artifact belongs to another REA version");
+        const nodeApiVersion = Number(host.nodeApiVersion);
+        if (!Number.isSafeInteger(nodeApiVersion) || nodeApiVersion < 8)
+            throw new Error("Windows native artifact requires Node-API 8 or newer");
+        const artifact = host.readArtifact();
+        if (createHash("sha256").update(artifact).digest("hex") !==
+            manifest.artifactSha256)
+            throw new Error("Windows native artifact SHA-256 does not match package metadata");
+        assertWindowsX64Artifact(artifact);
+        const binding = bindingSchema.parse(host.loadArtifact());
+        const inspection = inspectionSchema.parse(binding.call("inspect", []));
+        return { available: true, authority: { call: binding.call, inspection } };
+    }
+    catch (cause) {
+        return {
+            available: false,
+            reason: `REA Windows native controls are unavailable: ${cause instanceof Error ? cause.message : String(cause)}`,
+        };
+    }
+};
+const assertWindowsX64Artifact = (bytes) => {
+    if (bytes.length < 64 || bytes.toString("ascii", 0, 2) !== "MZ")
+        throw new Error("Windows native artifact is not a PE image");
+    const offset = bytes.readUInt32LE(0x3c);
+    if (offset > bytes.length - 26 ||
+        bytes.toString("ascii", offset, offset + 4) !== "PE\0\0" ||
+        bytes.readUInt16LE(offset + 4) !== 0x8664 ||
+        bytes.readUInt16LE(offset + 24) !== 0x20b)
+        throw new Error("Windows native artifact is not a Windows x64 PE32+ image");
+};
+let cached;
+/** Load only the package-owned artifact, lazily and once per process. */
+export const systemWindowsNativeAuthority = () => {
+    cached ??= loadWindowsNativeAuthority({
+        platform: process.platform,
+        architecture: process.arch,
+        nodeApiVersion: process.versions.napi,
+        packageVersion: PACKAGE_METADATA.version,
+        readManifest: () => {
+            const encoded = readFileSync(new URL("../../native/windows/build/manifest.json", import.meta.url), "utf8");
+            const value = JSON.parse(encoded);
+            return value;
+        },
+        readArtifact: () => readFileSync(new URL("../../native/windows/build/rea-windows-x64.node", import.meta.url)),
+        loadArtifact: () => {
+            const value = createRequire(import.meta.url)(fileURLToPath(new URL("../../native/windows/build/rea-windows-x64.node", import.meta.url)));
+            return value;
+        },
+    });
+    return cached;
+};
+/** Require the verified backend when an operation depends on native authority. */
+export const requireWindowsNativeAuthority = () => {
+    const loaded = systemWindowsNativeAuthority();
+    if (!loaded.available)
+        throw new Error(loaded.reason);
+    return loaded.authority;
+};

package/dist/windows/WindowsOwnedProcess.js

@@ -0,0 +1,170 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { z } from "zod";
+import { requireWindowsNativeAuthority, windowsHandleSchema, } from "./WindowsNativeLoader.js";
+const launchSchema = z.strictObject({
+    pid: z.number().int().positive().max(0xffff_ffff),
+    handle: windowsHandleSchema,
+    jobAssigned: z.literal(true),
+    killOnOwnerClose: z.literal(true),
+});
+const pollSchema = z.strictObject({
+    stdout: z.instanceof(Buffer),
+    stderr: z.instanceof(Buffer),
+    stdoutEnded: z.boolean(),
+    stderrEnded: z.boolean(),
+    exitCode: z.number().int().nonnegative().max(0xffff_ffff).nullable(),
+    activeProcesses: z.number().int().nonnegative(),
+});
+/** Encode one ordinary Windows argv token using the CRT backslash rules. */
+export const quoteWindowsProcessArgument = (value) => {
+    if (value.includes("\0"))
+        throw new TypeError("Windows process argument contains NUL");
+    return `"${value.replace(/(\\*)"/gu, '$1$1\\"').replace(/(\\+)$/u, "$1$1")}"`;
+};
+/** Process events and streams backed by a retained native Job Object. */
+export class WindowsOwnedProcess extends EventEmitter {
+    stdout = new PassThrough();
+    stderr = new PassThrough();
+    signalCode = null;
+    exitCode = null;
+    pid;
+    #handle;
+    #authority;
+    #settled;
+    #settle;
+    #closed = false;
+    #verifiedSettlement = false;
+    #failure;
+    #timer;
+    #cleanup;
+    constructor(command, arguments_, cwd, environment, verbatim) {
+        super();
+        this.#authority = requireWindowsNativeAuthority();
+        const entries = Object.entries(environment)
+            .filter((entry) => entry[1] !== undefined)
+            .map(([key, value]) => `${key}=${value}`);
+        const line = [
+            // cmd.exe parses its own command line rather than the CRT argv rules;
+            // its executable token must match the native drive-path representation.
+            quoteWindowsProcessArgument(command.replaceAll("/", "\\")),
+            ...arguments_.map((value) => verbatim ? value : quoteWindowsProcessArgument(value)),
+        ].join(" ");
+        const launched = launchSchema.parse(this.#authority.call("process_spawn", [
+            command,
+            line,
+            cwd ?? "",
+            entries,
+        ]));
+        this.pid = launched.pid;
+        this.#handle = launched.handle;
+        this.#settled = new Promise((resolve) => {
+            this.#settle = resolve;
+        });
+        this.#schedule();
+    }
+    /** Terminate the retained job, never a PID supplied by another caller. */
+    kill(signal) {
+        if (signal === 0)
+            return (!this.#closed &&
+                z
+                    .number()
+                    .parse(this.#authority.call("process_alive", [this.#handle])) > 0);
+        return this.#closed
+            ? false
+            : z
+                .boolean()
+                .parse(this.#authority.call("process_terminate", [this.#handle]));
+    }
+    /** Terminate and verify that the entire job has settled before releasing it. */
+    cleanup() {
+        this.#cleanup ??= this.#stop();
+        return this.#cleanup;
+    }
+    async #stop() {
+        if (this.#closed)
+            return this.#verifiedSettlement
+                ? { cleaned: true, signaled: false }
+                : {
+                    cleaned: false,
+                    reason: this.#failure ?? "Windows Job Object settlement was not verified",
+                };
+        let timer;
+        try {
+            const signaled = this.kill();
+            const settled = await Promise.race([
+                this.#settled.then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), 5_000);
+                }),
+            ]);
+            return settled && this.#verifiedSettlement
+                ? { cleaned: true, signaled }
+                : {
+                    cleaned: false,
+                    reason: this.#failure ??
+                        "Windows Job Object did not settle within the cleanup deadline",
+                };
+        }
+        catch (cause) {
+            return {
+                cleaned: false,
+                reason: cause instanceof Error ? cause.message : String(cause),
+            };
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (!this.#closed)
+                this.#release();
+        }
+    }
+    #schedule() {
+        this.#timer = setTimeout(() => this.#poll(), 25);
+    }
+    #poll() {
+        if (this.#closed)
+            return;
+        try {
+            const state = pollSchema.parse(this.#authority.call("process_poll", [this.#handle]));
+            if (state.stdout.length > 0)
+                this.stdout.write(state.stdout);
+            if (state.stderr.length > 0)
+                this.stderr.write(state.stderr);
+            if (state.exitCode !== null && this.exitCode === null) {
+                this.exitCode = state.exitCode;
+                this.emit("exit", state.exitCode, null);
+            }
+            if (state.exitCode !== null &&
+                state.stdoutEnded &&
+                state.stderrEnded &&
+                state.activeProcesses === 0) {
+                this.#verifiedSettlement = true;
+                this.#release();
+            }
+            else
+                this.#schedule();
+        }
+        catch (cause) {
+            const failure = cause instanceof Error ? cause : new Error(String(cause));
+            this.#failure = failure.message;
+            // Native lifecycle failures belong to the error/cleanup channels, never
+            // the captured stderr observation produced by the child itself.
+            if (this.listenerCount("error") > 0)
+                this.emit("error", failure);
+            this.#release();
+        }
+    }
+    #release() {
+        if (this.#closed)
+            return;
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#authority.call("process_close", [this.#handle]);
+        this.#closed = true;
+        this.stdout.end();
+        this.stderr.end();
+        this.#settle?.();
+        this.emit("close", this.exitCode, null);
+    }
+}

package/dist/windows/WindowsPrivateRuntime.js

@@ -0,0 +1,137 @@
+import { win32 } from "node:path";
+import { z } from "zod";
+import { requireWindowsNativeAuthority, windowsFileIdentitySchema, windowsHandleSchema, } from "./WindowsNativeLoader.js";
+const runtimeSchema = windowsFileIdentitySchema.extend({
+    path: z.string(),
+    handle: windowsHandleSchema,
+    privateDacl: z.literal(true),
+});
+const snapshotSchema = z.strictObject({
+    sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    source: windowsFileIdentitySchema,
+    snapshot: windowsFileIdentitySchema,
+});
+const fileSchema = windowsFileIdentitySchema.extend({
+    handle: windowsHandleSchema,
+});
+const runtimes = new Map();
+/** Retain private DACL and path handles until native recursive cleanup settles. */
+export class WindowsPrivateRuntime {
+    observation;
+    authority;
+    // One native snapshot can own cancellation for this runtime at a time. A
+    // second request throws ERROR_BUSY before #pending or its abort listener is
+    // replaced, so aborting a rejected request cannot cancel the accepted copy.
+    #pending;
+    #closed = false;
+    #closePromise;
+    constructor(observation, authority) {
+        this.observation = observation;
+        this.authority = authority;
+    }
+    /** Create a new directory with its private DACL installed at creation. */
+    static create(parent, prefix) {
+        const authority = requireWindowsNativeAuthority();
+        const observation = runtimeSchema.parse(authority.call("runtime_create", [parent, prefix]));
+        const runtime = new WindowsPrivateRuntime(observation, authority);
+        runtimes.set(observation.path.toLowerCase(), runtime);
+        return runtime;
+    }
+    /** Open a private child directory through retained, verified parent handles. */
+    mkdir(relativePath) {
+        this.authority.call("runtime_mkdir", [
+            this.observation.handle,
+            relativePath,
+        ]);
+    }
+    /** Write a new private file once and retain its immutable handle. */
+    writeFile(relativePath, content) {
+        this.authority.call("runtime_write", [
+            this.observation.handle,
+            relativePath,
+            Buffer.from(content),
+        ]);
+    }
+    /** Copy admitted source bytes and digest the bytes actually written. */
+    async snapshot(sourcePath, relativePath, signal) {
+        // Admission is synchronous; record ownership only after native acceptance.
+        const pending = Promise.resolve(this.authority.call("runtime_snapshot", [
+            this.observation.handle,
+            sourcePath,
+            relativePath,
+        ]));
+        this.#pending = pending;
+        const cancel = () => {
+            this.authority.call("runtime_snapshot_cancel", [this.observation.handle]);
+        };
+        signal?.addEventListener("abort", cancel, { once: true });
+        if (signal?.aborted === true)
+            cancel();
+        try {
+            return snapshotSchema.parse(await pending);
+        }
+        finally {
+            signal?.removeEventListener("abort", cancel);
+            if (this.#pending === pending)
+                this.#pending = undefined;
+        }
+    }
+    /** Read a private endpoint from an opened file, without re-opening its path. */
+    readFile(relativePath) {
+        const file = fileSchema.parse(this.authority.call("runtime_open", [
+            this.observation.handle,
+            relativePath,
+        ]));
+        try {
+            const chunks = [];
+            for (let offset = 0; offset < file.size;) {
+                const value = z
+                    .instanceof(Buffer)
+                    .parse(this.authority.call("read", [
+                    file.handle,
+                    offset,
+                    Math.min(65_536, file.size - offset),
+                ]));
+                if (value.length === 0)
+                    throw new Error("Private runtime file ended before its observed size");
+                offset += value.length;
+                chunks.push(value);
+            }
+            return Buffer.concat(chunks).toString("utf8");
+        }
+        finally {
+            this.authority.call("close", [file.handle]);
+        }
+    }
+    /** Remove owned objects by handle, unlinking reparse entries without traversal. */
+    close() {
+        this.#closePromise ??= this.#remove();
+        return this.#closePromise;
+    }
+    async #remove() {
+        if (this.#closed)
+            return;
+        if (this.#pending !== undefined)
+            this.authority.call("runtime_snapshot_cancel", [this.observation.handle]);
+        await this.#pending?.catch(() => undefined);
+        try {
+            this.authority.call("runtime_close", [this.observation.handle]);
+        }
+        finally {
+            this.#closed = true;
+            runtimes.delete(this.observation.path.toLowerCase());
+        }
+    }
+}
+/** Select an already-owned runtime; an arbitrary pathname cannot grant authority. */
+export const windowsPrivateRuntime = (rootPath) => {
+    const runtime = runtimes.get(rootPath.toLowerCase());
+    if (runtime === undefined)
+        throw new Error(`No native private runtime owns ${rootPath}`);
+    return runtime;
+};
+/** Read a runtime endpoint using the lease that owns its parent directory. */
+export const readWindowsPrivateRuntimeFile = (path) => {
+    const parent = win32.dirname(path);
+    return windowsPrivateRuntime(parent).readFile(win32.basename(path));
+};

package/install.sh

@@ -3,6 +3,10 @@ set -euo pipefail
 
 PACKAGE="rea-agents"
 REPOSITORY="morluto/rea"
+numeric_identifier='(0|[1-9][0-9]*)'
+prerelease_identifier="(${numeric_identifier}|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)"
+build_identifier='[0-9A-Za-z-]+'
+version_pattern="${numeric_identifier}\\.${numeric_identifier}\\.${numeric_identifier}(-${prerelease_identifier}(\\.${prerelease_identifier})*)?(\\+${build_identifier}(\\.${build_identifier})*)?"
 version="${REA_VERSION:-}"
 dry_run=false
 start_setup=true
@@ -55,28 +59,32 @@ fi
 platform="$(uname -s)"
 [[ "$platform" == "Darwin" || "$platform" == "Linux" ]] || fail "REA supports macOS and selected 64-bit Linux distributions."
 command -v curl >/dev/null 2>&1 || fail "curl is required. Install curl, then rerun this installer."
-command -v node >/dev/null 2>&1 || fail "Node.js 22.19+ or 24.11+ is required; install it from https://nodejs.org and retry."
+command -v node >/dev/null 2>&1 || fail "Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+ is required; install it from https://nodejs.org and retry."
 command -v npm >/dev/null 2>&1 || fail "npm is required; install it with Node.js and retry."
 
 node_version="$(node -p 'process.versions.node' 2>/dev/null || true)"
 IFS=. read -r node_major node_minor _node_patch <<<"$node_version"
 [[ "$node_major" =~ ^[0-9]+$ && "$node_minor" =~ ^[0-9]+$ ]] || fail "the active Node.js version could not be read. Check that node works and is on PATH, then retry."
-if ! ((node_major == 22 && node_minor >= 19 || node_major >= 24)); then
-  fail "Node.js $node_version is unsupported; use Node.js 22.19+ or 24.11+."
-fi
-if ((node_major == 24 && node_minor < 11)); then
-  fail "Node.js $node_version is unsupported; use Node.js 24.11 or newer."
+if ! [[ "$_node_patch" =~ ^[0-9]+(\+[0-9A-Za-z.-]+)?$ ]] ||
+  ! ((node_major == 22 && node_minor >= 19 || node_major == 24 && node_minor >= 11 || node_major >= 26)); then
+  fail "Node.js $node_version is unsupported; use Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+."
 fi
 
 if [[ -n "$version" ]]; then
-  [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$ ]] || fail "version must be an exact semantic version."
+  [[ "$version" =~ ^${version_pattern}$ ]] || fail "version must be an exact semantic version."
 else
   release_json="$(curl -fsSL --proto '=https' --tlsv1.2 --retry 3 -H 'Accept: application/vnd.github+json' "https://api.github.com/repos/$REPOSITORY/releases/latest")" || fail "the latest REA release could not be resolved. Check network access or pass --version VERSION, then retry."
   tag="$(printf '%s' "$release_json" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{const v=JSON.parse(s).tag_name;if(typeof v!=="string")process.exit(1);process.stdout.write(v)})' 2>/dev/null)" || fail "the release response was invalid. Retry later or pass --version VERSION."
-  [[ "$tag" =~ ^rea-agents-([0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?)$ ]] || fail "the latest release tag was invalid. Retry later or pass --version VERSION."
+  [[ "$tag" =~ ^rea-agents-(${version_pattern})$ ]] || fail "the latest release tag was invalid. Retry later or pass --version VERSION."
   version="${BASH_REMATCH[1]}"
 fi
 
+# npm's exact-version resolver cleans build metadata from the requested version,
+# so it may install the base release and make the post-install identity check fail.
+if [[ "$version" =~ \+ ]]; then
+  fail "npm cannot install an exact version with build metadata. Pass a version without build metadata, then retry."
+fi
+
 prefix_args=()
 if [[ "$platform" == "Linux" ]]; then
   prefix_args=(--prefix "$HOME/.local")

package/native/windows/README.md

@@ -0,0 +1,107 @@
+# Windows native controls
+
+REA ships one Windows x64 Node-API 8 addon. Users do not compile it or install
+another runtime. Ghidra and a full JDK remain bring-your-own prerequisites.
+The addon uses Windows 10+ APIs and admits fixed local NTFS volumes only.
+
+The package owns the artifact path. The loader checks the package version,
+ABI, Node-API compatibility, PE architecture, and SHA-256 before loading it.
+There is no environment override for loading an arbitrary native module.
+
+## Build
+
+The artifact lane requires Linux, MinGW-w64 `x86_64-w64-mingw32-g++`,
+`x86_64-w64-mingw32-dlltool`, and `tar`. It never installs these commands.
+Node-API headers are reused from the build cache or downloaded from the
+pinned official Node release with its published SHA-256 checked.
+
+```sh
+npm run build:windows-native
+npm run verify:windows-native:artifact
+npm pack
+```
+
+`build/` is ignored by Git. The npm file inventory includes only the addon and
+its manifest. Release CI builds both, and `prepublishOnly` rejects a missing,
+stale, mismatched, or wrong-architecture artifact. A development tarball built
+without this lane reports Windows native controls as unavailable.
+
+## Boundaries
+
+- Opaque Node objects carry a native type tag, resource kind, and closed state.
+  A pathname, serialized object, or forged handle cannot grant authority.
+- Input admission opens every component with `OPEN_REPARSE_POINT`, verifies
+  the actual NTFS object, and retains handles that deny replacement and source
+  writing. An admitted child keeps each ancestor nonempty; ancestor handles
+  permit unrelated writes while NTFS rejects in-place reparse conversion. Volume serial, 128-bit file ID, final handle path,
+  requested path, size, and digest observations are preserved separately.
+- New runtime roots and private child objects are created relative to admitted
+  parent handles with `NtCreateFile`. A protected DACL and current-user owner
+  are installed at creation. Readback permits exactly the current user and SYSTEM. Child
+  files inherit this boundary; private files are also checked by handle.
+- Snapshots stream through a 64 KiB buffer on a Node async worker. Cancellation
+  is checked between reads, cleanup waits for settlement, and the digest
+  commits to the bytes written. Descriptor and snapshot handles remain held
+  until runtime cleanup.
+  Snapshot ownership is single-flight per runtime: an overlapping request fails
+  with `ERROR_BUSY` before acquiring cancellation ownership. The TypeScript owner
+  records only the accepted promise and abort listener; aborting a rejected copy
+  must not cancel the active copy.
+- `PROC_THREAD_ATTRIBUTE_JOB_LIST` assigns a suspended child atomically to an
+  unnamed, non-inherited Job Object. Membership and kill-on-close policy are
+  checked before resume. Breakaway is disabled, and cleanup waits for all
+  job members and captured output, including detached descendants.
+- Only the suspended child's default file owner is normalized. Caller token
+  privileges and ownership remain unchanged. Caller CPU affinity and process
+  priority are preserved in the child. Environment names are sorted and
+  deduplicated using Windows ordinal comparison, preserving their native Unicode
+  semantics and caller-selected values.
+- Cleanup walks locked directory objects, removes files by handle, and unlinks
+  reparse entries without traversing their targets. Normal close, cancellation,
+  startup failure, and timeout release provider resources. Abrupt owner death
+  kills the owned job; it can leave private runtime files for later operator
+  cleanup and does not claim transactional deletion after a crash.
+
+Windows failures retain their constraint, requested coordinate, Win32 code,
+and system message. Unsupported filesystems and reparse paths are distinct
+from OS access denial and missing packaged controls.
+
+Ordinary drive-absolute paths accept backslashes, forward slashes, or mixed
+separators. File identity retains the original requested spelling. Separator
+translation does not resolve dot components, repeated separators, or extend
+the supported device/UNC namespaces; existing admission checks still apply.
+
+The bearer-token descriptor remains under its immutable private lease until
+`runtime_close` on Windows; POSIX removes the descriptor after the bridge reads
+it. Job ownership guarantees process termination on owner death, not deletion
+of private files after a crash. SUBST drive aliases and changing DOS-device
+namespaces are outside the verified P0 scope and are not detected as a separate
+alias policy. Mounted-folder paths that report a reparse tag are rejected by
+component admission; broader namespace variants remain unverified. Preserve
+requested and final handle coordinates rather than treating them as one identity.
+
+## Real verification
+
+```powershell
+npm run verify:windows-native
+npm run verify:ghidra:windows
+```
+
+The native lane checks DACL readback independently, source write/replacement
+rejection, unrelated sibling renames, reparse rejection, immutable snapshots,
+asynchronous cancellation, cleanup containment,
+descendant termination, unrelated-process preservation, normal exit, owner
+close, and forced owner exit. An optional independently built
+`tests/fixtures/windows/processBoundary.cc` executable adds breakaway and
+caller/child token observations and an in-place ancestor reparse attempt:
+
+```powershell
+node scripts/verify-windows-native.mjs . C:\fixtures\process-boundary.exe
+```
+
+`nonAdminRunner.cc` is a test-only launcher for an elevated development shell.
+It duplicates an existing non-elevated Explorer token belonging to the same
+user, creates private temporary window-station objects, and launches the test
+inside a kill-on-close fixture job. It does not create accounts, modify host
+policy, or change the caller's token. A real-provider claim must additionally
+verify the packaged CLI and MCP on that ordinary-user token.

package/native/windows/build/manifest.json

@@ -0,0 +1,9 @@
+{
+  "packageVersion": "5.0.0",
+  "platform": "win32",
+  "architecture": "x64",
+  "abiVersion": 1,
+  "nodeApiVersion": 8,
+  "artifact": "rea-windows-x64.node",
+  "artifactSha256": "f9ae5fa99de3207da630f59be2450febd60c79ed1862abfcf90e9cf080c2c977"
+}