morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 07:47:29 +00:00

[GH-ISSUE #6050] [Bug] Missing Windows worker controls surface as execution_failure instead of capability_unavailable #3695

New issue

Closed

opened 2026-10-31 00:43:08 +00:00 by bsakaguchi · 0 comments

bsakaguchi commented

2026-10-31 00:43:08 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 21, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/6050

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

Provider or capability discovery

Observed behavior

When an admitted Windows native artifact omits the optional jobMemoryLimit control, trace_web_source_location under Windows+Bun correctly refuses to launch its bounded codec. However, the public MCP error reports execution_failure and generic rea doctor advice. The specific instruction to use a matching current Windows x64 package appears only in nested diagnostics.

I reproduced this through an in-memory MCP client/server on macOS with simulated Windows+Bun host facts and a simulated native authority. The service, decoder, process launcher, refusal and public error projection are production code. I did not run Windows, Bun or the native addon.

The related protocolStdin refusal also throws plain Error; its JavaScript worker propagation is source-derived rather than an end-to-end MCP observation.

Reproduction

Save the test below as tests/process-global/windowsCapabilityReproduction.test.ts in the source checkout with locked dependencies installed. Run it with one worker:

REPRO_SCRATCH="$(mktemp -d)" ./node_modules/.bin/vitest run tests/process-global/windowsCapabilityReproduction.test.ts --maxWorkers=1

The test supplies Windows+Bun facts through the real memory-limit policy's existing host parameter, overrides process.platform for Windows launcher selection, and uses the loader's real metadata/digest/inspection validation with synthetic package inputs. Private-root acquisition and ownership preparation are substituted. The MCP request uses the repository's retained-artifact fixture and real decoder.

import { createHash } from "node:crypto";
import { mkdtemp, rm } from "node:fs/promises";
import { join } from "node:path";
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
import { expect, it, vi } from "vitest";
import { WebSourceLocationService } from "../../src/application/WebSourceLocationService.js";
import { ok } from "../../src/domain/result.js";
import { createServer } from "../../src/server/createServer.js";
import { createTestBinarySession } from "../fixtures/binarySession.js";
import { webSourceLocationArgs, webSourceLocationFixture } from "../fixtures/webSourceLocation.js";
import * as nativeLoader from "../../src/windows/WindowsNativeLoader.js";
import { WindowsOwnedProcess } from "../../src/windows/WindowsOwnedProcess.js";
import { inspectWindowsNativeReadiness, windowsNativeCapabilities } from "../../src/process/WindowsAuthority.js";
import { systemProcessOwnershipHost } from "../../src/process/ProcessOwnershipObservation.js";

vi.mock("../../src/process/JavaScriptWorkerMemoryLimit.js", async (original) => {
  const actual = await original<typeof import("../../src/process/JavaScriptWorkerMemoryLimit.js")>();
  return { ...actual, javaScriptWorkerMemoryLimitBytes: (heap: number) => actual.javaScriptWorkerMemoryLimitBytes(heap, { platform: "win32", versions: { node: "24.3.0", bun: "1.4.2" } }) };
});

it("projects a missing owned-process control through the public MCP source-map tool", async () => {
  const platform = Object.getOwnPropertyDescriptor(process, "platform")!;
  const bun = Object.getOwnPropertyDescriptor(process.versions, "bun");
  const bytes = Buffer.alloc(128);
  bytes.write("MZ"); bytes.writeUInt32LE(64, 0x3c);
  bytes.write("PE\0\0", 64, "ascii");
  bytes.writeUInt16LE(0x8664, 68); bytes.writeUInt16LE(0x20b, 88);
  const nativeCall = vi.fn(() => { throw new Error("must refuse before native process_spawn"); });
  const loaded = nativeLoader.loadWindowsNativeAuthority({
    platform: "win32", architecture: "x64", nodeApiVersion: "8", packageVersion: "6.7.0",
    readManifest: () => ({ packageVersion: "6.7.0", platform: "win32", architecture: "x64", abiVersion: 1, nodeApiVersion: 8, artifact: "rea-windows-x64.node", artifactSha256: createHash("sha256").update(bytes).digest("hex") }),
    readArtifact: () => bytes,
    loadArtifact: () => ({ call: () => ({ abiVersion: 1, nodeApiVersion: 8, architecture: "x64", filesystem: { requestedPath: "C:\\probe", finalPath: "C:\\probe", filesystem: "NTFS", volumeSerial: "0".repeat(16), fileId: "0".repeat(32), size: 0, directory: true }, privateDacl: true, privateBridgeDescriptorAccess: true, atomicJobAssignment: true, killOnOwnerClose: true, protocolStdin: true }) }),
  });
  expect(loaded.available).toBe(true);
  if (!loaded.available) throw new Error(loaded.reason);
  const authority = { ...loaded.authority, call: nativeCall };
  const scratch = process.env.REPRO_SCRATCH;
  if (!scratch) throw new Error("Set REPRO_SCRATCH to an empty scratch directory");
  const root = await mkdtemp(join(scratch, "runtime-"));
  let rootClosed = false;
  const session = createTestBinarySession(() => { throw new Error("binary provider must not start"); });
  let client: Client | undefined;
  let server: ReturnType<typeof createServer> | undefined;
  try {
    Object.defineProperty(process, "platform", { ...platform, value: "win32" });
    Object.defineProperty(process.versions, "bun", { configurable: true, value: "1.4.2" });
    const { SourceMapDecoder } = await import("../../src/javascript/sourceMaps/SourceMapDecoder.js");
    const { SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES } = await import("../../src/javascript/sourceMaps/SourceMapCommand.js");
    expect(SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES).toBeGreaterThan(0);
    vi.spyOn(nativeLoader, "requireWindowsNativeAuthority").mockReturnValue(authority);
    vi.spyOn(systemProcessOwnershipHost, "prepare").mockResolvedValue(undefined);
    const decoder = new SourceMapDecoder({
      prepareOwnership: async () => {},
      createRuntime: async () => ({ path: root, close: async () => { await rm(root, { recursive: true, force: true }); rootClosed = true; } }),
    });
    const service = new WebSourceLocationService({ load: async () => ok(webSourceLocationFixture()) }, decoder);
    server = createServer({ kind: "session", session }, { webSourceLocation: service });
    client = new Client({ name: "capability-reproduction", version: "1" });
    const [ct, st] = InMemoryTransport.createLinkedPair();
    await server.connect(st); await client.connect(ct);
    const response = await client.callTool({ name: "trace_web_source_location", arguments: webSourceLocationArgs });
    console.log("MCP response", JSON.stringify(response));
    expect(response.isError).toBe(true);
    expect(JSON.stringify(response)).toContain("execution_failure");
    expect(JSON.stringify(response)).toContain("does not support Job Object memory limits");
    expect(JSON.stringify(response)).toContain("rea doctor");
    expect(nativeCall).not.toHaveBeenCalled();
    expect(rootClosed).toBe(true);
    const readiness = inspectWindowsNativeReadiness("win32", loaded);
    console.log("native readiness", JSON.stringify(readiness), JSON.stringify(windowsNativeCapabilities("win32", readiness)));
    expect(readiness).toEqual({ available: true });
    const withoutStdin = { ...authority, inspection: { ...authority.inspection, protocolStdin: false } };
    let refusal: unknown;
    try { new WindowsOwnedProcess("C:\\runtime\\node.exe", [], undefined, {}, false, { authority: withoutStdin, protocolStdin: true }); }
    catch (cause) { refusal = cause; }
    expect(refusal).toBeInstanceOf(Error);
    expect((refusal as Error).constructor).toBe(Error);
    console.log("stdin refusal", (refusal as Error).message);
    expect(nativeCall).not.toHaveBeenCalled();
    await decoder.close();
  } finally {
    Object.defineProperty(process, "platform", platform);
    if (bun) Object.defineProperty(process.versions, "bun", bun); else Reflect.deleteProperty(process.versions, "bun");
    vi.restoreAllMocks();
    await client?.close(); await server?.close(); await session.close();
    await rm(root, { recursive: true, force: true });
  }
});

Observed result: one test passed. The assertions intentionally record the current incorrect public classification. No native process_spawn call occurred, and the acquired runtime directory was removed.

Expected behavior

Preserve the pre-launch refusal and return a typed unavailable-capability outcome, such as code: capability_unavailable, retryable: false, with the missing control and matching-package recovery visible in the primary message/remediation.

This is an expected capability state: the loader schema permits omitted controls, and its compatibility test explicitly admits earlier artifacts without jobMemoryLimit. The error contract calls for tagged expected failures, and AnalysisCapabilityUnavailableError represents a provider unable to execute a declared operation. The JADX admission check already treats missing protocol stdin as a typed runtime prerequisite failure.

Impact and scope

P2: callers receive the wrong machine-readable failure kind and primary recovery advice for a known missing capability. They cannot distinguish this expected prerequisite gap from a provider execution fault using the public code. The package remedy remains available in diagnostics.

The observed scope is the simulated Windows+Bun source-map path with an artifact accepted by the loader but lacking jobMemoryLimit. The same plain-error pattern for protocol stdin is present in the JavaScript worker path. Real-world frequency, real Windows execution and recovery after replacing a package were not measured. Correctly refusing to start a worker without its required controls is preserved; no security bypass or data loss was observed.

REA version

5241597594; source package version 6.7.0.

Runtime and platform

Executed on macOS 27.0.1, Darwin 27.0.0, arm64, Node.js v26.12.0, Vitest 5.0.3. Windows x64 native metadata and Windows+Bun 1.4.2 policy facts were simulated; no actual Windows/Bun/native-addon run.

Target and artifact context

Repository fixture: retained generated JavaScript and a version-3 source map containing one mapping. Native package input: synthetic digest-valid PE32+ x64 bytes, same-version manifest and valid required inspection facts, with protocolStdin: true and jobMemoryLimit omitted. No target process was started.

Interface

MCP

Earliest failure stage

Setup or provider admission

Relevant output or evidence

The public trace_web_source_location MCP response contained this error:

{
  "code": "execution_failure",
  "category": "execution_failure",
  "message": "Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed.",
  "retryable": false,
  "remediation": {
    "action": "Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed."
  },
  "details": {
    "provider_id": "source-map-decoder",
    "operation": "trace_web_source_location",
    "diagnostics": {
      "map_path": "/analysis/app.js.map",
      "error_message": "The bundled Windows native artifact does not support Job Object memory limits; use a matching current Windows x64 REA package."
    }
  }
}

For the same admitted fixture, inspectWindowsNativeReadiness("win32", loaded) returned {"available":true}; the existing three security capability entries were all available and did not identify the optional-control gap. This was the native-readiness summary, not a full rea doctor execution.

The additional constructor probe observed a plain Error with: The bundled Windows native artifact does not support owned protocol stdin; use a matching current Windows x64 REA package.

Typed outcome or recovery expected

A non-retryable AnalysisCapabilityUnavailableError or equivalent typed prerequisite outcome carrying the missing control and matching-package remediation. The existing public category for that error is unsupported_provider; its code is capability_unavailable.

Analysis or suspected cause

The two refusals throw plain Error. SourceMapCommand.failure only recognizes AnalysisError and PrivateRuntimeRootUnavailableError before wrapping other causes as ProviderAdapterError. The public projection maps that to execution_failure.

Source-derived additional scope: the JavaScript worker launch requests piped stdin and the applicable process limit; its failure projection has the same plain-error fallback. The readiness summary checks loader success, while the capability summary describes only the existing three security controls.

Additional context

The inspected upstream revision was 6d356b84344659085f2b912857b5e27fe0160c9b. The relevant launch refusals, loader schema, source-map failure projection and native-readiness summary were unchanged. No fix is proposed to relax the required process controls.

Originally created by @coygeek on GitHub (Oct 21, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/6050 ### Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area Provider or capability discovery ### Observed behavior When an admitted Windows native artifact omits the optional `jobMemoryLimit` control, `trace_web_source_location` under Windows+Bun correctly refuses to launch its bounded codec. However, the public MCP error reports `execution_failure` and generic `rea doctor` advice. The specific instruction to use a matching current Windows x64 package appears only in nested diagnostics. I reproduced this through an in-memory MCP client/server on macOS with simulated Windows+Bun host facts and a simulated native authority. The service, decoder, process launcher, refusal and public error projection are production code. I did not run Windows, Bun or the native addon. The related `protocolStdin` refusal also throws plain `Error`; its JavaScript worker propagation is source-derived rather than an end-to-end MCP observation. ### Reproduction Save the test below as `tests/process-global/windowsCapabilityReproduction.test.ts` in the source checkout with locked dependencies installed. Run it with one worker: ```sh REPRO_SCRATCH="$(mktemp -d)" ./node_modules/.bin/vitest run tests/process-global/windowsCapabilityReproduction.test.ts --maxWorkers=1 ``` The test supplies Windows+Bun facts through the real memory-limit policy's existing host parameter, overrides `process.platform` for Windows launcher selection, and uses the loader's real metadata/digest/inspection validation with synthetic package inputs. Private-root acquisition and ownership preparation are substituted. The MCP request uses the repository's retained-artifact fixture and real decoder. ```ts import { createHash } from "node:crypto"; import { mkdtemp, rm } from "node:fs/promises"; import { join } from "node:path"; import { Client, InMemoryTransport } from "@modelcontextprotocol/client"; import { expect, it, vi } from "vitest"; import { WebSourceLocationService } from "../../src/application/WebSourceLocationService.js"; import { ok } from "../../src/domain/result.js"; import { createServer } from "../../src/server/createServer.js"; import { createTestBinarySession } from "../fixtures/binarySession.js"; import { webSourceLocationArgs, webSourceLocationFixture } from "../fixtures/webSourceLocation.js"; import * as nativeLoader from "../../src/windows/WindowsNativeLoader.js"; import { WindowsOwnedProcess } from "../../src/windows/WindowsOwnedProcess.js"; import { inspectWindowsNativeReadiness, windowsNativeCapabilities } from "../../src/process/WindowsAuthority.js"; import { systemProcessOwnershipHost } from "../../src/process/ProcessOwnershipObservation.js"; vi.mock("../../src/process/JavaScriptWorkerMemoryLimit.js", async (original) => { const actual = await original<typeof import("../../src/process/JavaScriptWorkerMemoryLimit.js")>(); return { ...actual, javaScriptWorkerMemoryLimitBytes: (heap: number) => actual.javaScriptWorkerMemoryLimitBytes(heap, { platform: "win32", versions: { node: "24.3.0", bun: "1.4.2" } }) }; }); it("projects a missing owned-process control through the public MCP source-map tool", async () => { const platform = Object.getOwnPropertyDescriptor(process, "platform")!; const bun = Object.getOwnPropertyDescriptor(process.versions, "bun"); const bytes = Buffer.alloc(128); bytes.write("MZ"); bytes.writeUInt32LE(64, 0x3c); bytes.write("PE\0\0", 64, "ascii"); bytes.writeUInt16LE(0x8664, 68); bytes.writeUInt16LE(0x20b, 88); const nativeCall = vi.fn(() => { throw new Error("must refuse before native process_spawn"); }); const loaded = nativeLoader.loadWindowsNativeAuthority({ platform: "win32", architecture: "x64", nodeApiVersion: "8", packageVersion: "6.7.0", readManifest: () => ({ packageVersion: "6.7.0", platform: "win32", architecture: "x64", abiVersion: 1, nodeApiVersion: 8, artifact: "rea-windows-x64.node", artifactSha256: createHash("sha256").update(bytes).digest("hex") }), readArtifact: () => bytes, loadArtifact: () => ({ call: () => ({ abiVersion: 1, nodeApiVersion: 8, architecture: "x64", filesystem: { requestedPath: "C:\\probe", finalPath: "C:\\probe", filesystem: "NTFS", volumeSerial: "0".repeat(16), fileId: "0".repeat(32), size: 0, directory: true }, privateDacl: true, privateBridgeDescriptorAccess: true, atomicJobAssignment: true, killOnOwnerClose: true, protocolStdin: true }) }), }); expect(loaded.available).toBe(true); if (!loaded.available) throw new Error(loaded.reason); const authority = { ...loaded.authority, call: nativeCall }; const scratch = process.env.REPRO_SCRATCH; if (!scratch) throw new Error("Set REPRO_SCRATCH to an empty scratch directory"); const root = await mkdtemp(join(scratch, "runtime-")); let rootClosed = false; const session = createTestBinarySession(() => { throw new Error("binary provider must not start"); }); let client: Client | undefined; let server: ReturnType<typeof createServer> | undefined; try { Object.defineProperty(process, "platform", { ...platform, value: "win32" }); Object.defineProperty(process.versions, "bun", { configurable: true, value: "1.4.2" }); const { SourceMapDecoder } = await import("../../src/javascript/sourceMaps/SourceMapDecoder.js"); const { SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES } = await import("../../src/javascript/sourceMaps/SourceMapCommand.js"); expect(SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES).toBeGreaterThan(0); vi.spyOn(nativeLoader, "requireWindowsNativeAuthority").mockReturnValue(authority); vi.spyOn(systemProcessOwnershipHost, "prepare").mockResolvedValue(undefined); const decoder = new SourceMapDecoder({ prepareOwnership: async () => {}, createRuntime: async () => ({ path: root, close: async () => { await rm(root, { recursive: true, force: true }); rootClosed = true; } }), }); const service = new WebSourceLocationService({ load: async () => ok(webSourceLocationFixture()) }, decoder); server = createServer({ kind: "session", session }, { webSourceLocation: service }); client = new Client({ name: "capability-reproduction", version: "1" }); const [ct, st] = InMemoryTransport.createLinkedPair(); await server.connect(st); await client.connect(ct); const response = await client.callTool({ name: "trace_web_source_location", arguments: webSourceLocationArgs }); console.log("MCP response", JSON.stringify(response)); expect(response.isError).toBe(true); expect(JSON.stringify(response)).toContain("execution_failure"); expect(JSON.stringify(response)).toContain("does not support Job Object memory limits"); expect(JSON.stringify(response)).toContain("rea doctor"); expect(nativeCall).not.toHaveBeenCalled(); expect(rootClosed).toBe(true); const readiness = inspectWindowsNativeReadiness("win32", loaded); console.log("native readiness", JSON.stringify(readiness), JSON.stringify(windowsNativeCapabilities("win32", readiness))); expect(readiness).toEqual({ available: true }); const withoutStdin = { ...authority, inspection: { ...authority.inspection, protocolStdin: false } }; let refusal: unknown; try { new WindowsOwnedProcess("C:\\runtime\\node.exe", [], undefined, {}, false, { authority: withoutStdin, protocolStdin: true }); } catch (cause) { refusal = cause; } expect(refusal).toBeInstanceOf(Error); expect((refusal as Error).constructor).toBe(Error); console.log("stdin refusal", (refusal as Error).message); expect(nativeCall).not.toHaveBeenCalled(); await decoder.close(); } finally { Object.defineProperty(process, "platform", platform); if (bun) Object.defineProperty(process.versions, "bun", bun); else Reflect.deleteProperty(process.versions, "bun"); vi.restoreAllMocks(); await client?.close(); await server?.close(); await session.close(); await rm(root, { recursive: true, force: true }); } }); ``` Observed result: one test passed. The assertions intentionally record the current incorrect public classification. No native `process_spawn` call occurred, and the acquired runtime directory was removed. ### Expected behavior Preserve the pre-launch refusal and return a typed unavailable-capability outcome, such as `code: capability_unavailable`, `retryable: false`, with the missing control and matching-package recovery visible in the primary message/remediation. This is an expected capability state: the [loader schema](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/windows/WindowsNativeLoader.ts#L38-L50) permits omitted controls, and its [compatibility test](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/windows/WindowsNativeLoader.test.ts#L86-L100) explicitly admits earlier artifacts without `jobMemoryLimit`. The [error contract](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/AGENTS.md#L31) calls for tagged expected failures, and [AnalysisCapabilityUnavailableError](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/analysisErrorCore.ts#L123-L149) represents a provider unable to execute a declared operation. The [JADX admission check](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/android/JadxConfiguration.ts#L490-L506) already treats missing protocol stdin as a typed runtime prerequisite failure. ### Impact and scope P2: callers receive the wrong machine-readable failure kind and primary recovery advice for a known missing capability. They cannot distinguish this expected prerequisite gap from a provider execution fault using the public code. The package remedy remains available in diagnostics. The observed scope is the simulated Windows+Bun source-map path with an artifact accepted by the loader but lacking `jobMemoryLimit`. The same plain-error pattern for protocol stdin is present in the JavaScript worker path. Real-world frequency, real Windows execution and recovery after replacing a package were not measured. Correctly refusing to start a worker without its required controls is preserved; no security bypass or data loss was observed. ### REA version 52415975942a4b9c53a817915b313ccc404f280e; source package version 6.7.0. ### Runtime and platform Executed on macOS 27.0.1, Darwin 27.0.0, arm64, Node.js v26.12.0, Vitest 5.0.3. Windows x64 native metadata and Windows+Bun 1.4.2 policy facts were simulated; no actual Windows/Bun/native-addon run. ### Target and artifact context Repository fixture: retained generated JavaScript and a version-3 source map containing one mapping. Native package input: synthetic digest-valid PE32+ x64 bytes, same-version manifest and valid required inspection facts, with `protocolStdin: true` and `jobMemoryLimit` omitted. No target process was started. ### Interface MCP ### Earliest failure stage Setup or provider admission ### Relevant output or evidence The public `trace_web_source_location` MCP response contained this error: ```json { "code": "execution_failure", "category": "execution_failure", "message": "Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed.", "retryable": false, "remediation": { "action": "Analysis could not complete. Run `rea doctor` and review the reported details; repeating the unchanged request is not expected to succeed." }, "details": { "provider_id": "source-map-decoder", "operation": "trace_web_source_location", "diagnostics": { "map_path": "/analysis/app.js.map", "error_message": "The bundled Windows native artifact does not support Job Object memory limits; use a matching current Windows x64 REA package." } } } ``` For the same admitted fixture, `inspectWindowsNativeReadiness("win32", loaded)` returned `{"available":true}`; the existing three security capability entries were all available and did not identify the optional-control gap. This was the native-readiness summary, not a full `rea doctor` execution. The additional constructor probe observed a plain `Error` with: `The bundled Windows native artifact does not support owned protocol stdin; use a matching current Windows x64 REA package.` ### Typed outcome or recovery expected A non-retryable `AnalysisCapabilityUnavailableError` or equivalent typed prerequisite outcome carrying the missing control and matching-package remediation. The existing public category for that error is `unsupported_provider`; its code is `capability_unavailable`. ### Analysis or suspected cause The [two refusals](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/windows/WindowsOwnedProcess.ts#L92-L107) throw plain `Error`. [SourceMapCommand.failure](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/javascript/sourceMaps/SourceMapCommand.ts#L287-L312) only recognizes `AnalysisError` and `PrivateRuntimeRootUnavailableError` before wrapping other causes as `ProviderAdapterError`. The [public projection](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/analysisErrorProjection.ts#L249-L262) maps that to `execution_failure`. Source-derived additional scope: the [JavaScript worker launch](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/javascript/analysis/JavaScriptAnalysisWorker.ts#L518-L545) requests piped stdin and the applicable process limit; its [failure projection](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/javascript/analysis/JavaScriptAnalysisWorker.ts#L1073-L1088) has the same plain-error fallback. The [readiness summary](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/process/WindowsAuthority.ts#L73-L74) checks loader success, while the [capability summary](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/process/WindowsAuthority.ts#L103-L123) describes only the existing three security controls. ### Additional context The inspected upstream revision was `6d356b84344659085f2b912857b5e27fe0160c9b`. The relevant launch refusals, loader schema, source-map failure projection and native-readiness summary were unchanged. No fix is proposed to relax the required process controls.

bsakaguchi closed this issue

2026-10-31 00:43:09 +00:00

bsakaguchi referenced this issue

2026-11-01 21:10:58 +00:00

[GH-ISSUE #3796] [Tracker] Open feature requests by area (October 2026) #1471