morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #7662] [Bug] PE import and load-config inspection returns PE Evidence for a ZZ-prefixed file #4585

New issue

Closed

opened 2026-10-31 00:51:01 +00:00 by bsakaguchi · 1 comment

bsakaguchi commented

2026-10-31 00:51:01 +00:00

Owner

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

Before submitting

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

Area

Native analysis or decompilation

Observed behavior

These public commands both exit 0 for a synthetic file beginning with ZZ that contains PE32+ headers at the offset declared by the bytes at offset 60:

node scripts/rea.mjs inspect-pe-imports "$WORK/zz.exe" --format json
node scripts/rea.mjs inspect-pe-load-config "$WORK/zz.exe" --format json

Both return Evidence with subject.format: "pe" and normalized_result.format: "pe32-plus". Imports reports complete coverage with zero imports. Load-config returns tls: null, load_config: null and zero examined callbacks; it has no coverage field.

For the same file, resources and certificates reject the missing MZ header, artifact inspection rejects the binary format, and native exports rejects the target. An MZ-prefixed control succeeds through all six commands. The pair differs at exactly byte 0.

Reproduction

Use the baseline below with its dependencies and compiled runtime present, and Node.js v24.22.1 on PATH.
Run the script from the checkout root. It generates the pair, isolates HOME/XDG state, places fixture package-manager launchers first on PATH, runs six static inspectors and deletes its temporary directory.

python3 -I - <<'PY'
from pathlib import Path
import json, os, shutil, struct, subprocess, tempfile

repo = Path.cwd()
node = shutil.which("node")
assert node is not None
assert subprocess.check_output([node, "--version"], text=True).strip() == "v24.22.1"
commands = ["inspect-pe-imports", "inspect-pe-load-config",
            "inspect-pe-certificates", "inspect-pe-resources",
            "inspect-artifact", "inspect-native-exports"]
with tempfile.TemporaryDirectory(prefix="rea-pe-magic-") as directory:
    work = Path(directory)
    for name in ["home", "config", "cache", "data", "state", "runtime", "temp", "bin"]:
        (work / name).mkdir()
    for name in ["npx", "npm", "bun"]:
        launcher = work / "bin" / name
        launcher.write_text('#!/bin/sh\nprintf "invoked\\n" >> "' +
                            str(work / "package-manager-called") + '"\nexit 97\n')
        launcher.chmod(0o755)
    env = {"PATH": str(work / "bin") + os.pathsep + str(Path(node).parent) +
                   os.pathsep + os.environ.get("PATH", ""),
           "HOME": str(work / "home"), "TMPDIR": str(work / "temp")}
    for variable, name in [("XDG_CONFIG_HOME", "config"), ("XDG_CACHE_HOME", "cache"),
                           ("XDG_DATA_HOME", "data"), ("XDG_STATE_HOME", "state"),
                           ("XDG_RUNTIME_DIR", "runtime")]:
        env[variable] = str(work / name)
    image = bytearray(1024)
    def put(fmt, offset, value):
        struct.pack_into("<" + fmt, image, offset, value)
    put("I", 0x3c, 0x80)
    image[0x80:0x84] = bytes([0x50, 0x45, 0, 0])
    for offset, value in [(0x84, 0x8664), (0x86, 1), (0x94, 240), (0x96, 0x22)]:
        put("H", offset, value)
    optional = 0x98
    for fmt, offset, value in [
        ("H", 0, 0x20b), ("I", 16, 0x1000), ("Q", 24, 0x140000000),
        ("I", 32, 0x1000), ("I", 36, 0x200), ("I", 56, 0x2000),
        ("I", 60, 0x200), ("H", 68, 3), ("I", 108, 16),
    ]:
        put(fmt, optional + offset, value)
    section = optional + 240
    image[section:section + 8] = b".rdata" + bytes(2)
    for offset, value in [(8, 0x1000), (12, 0x1000), (16, 0x200),
                          (20, 0x200), (36, 0x40000040)]:
        put("I", section + offset, value)
    originals = {}
    for name, prefix in [("mz.exe", b"MZ"), ("zz.exe", b"ZZ")]:
        image[:2] = prefix
        originals[name] = bytes(image)
        (work / name).write_bytes(image)
    assert [i for i, (a, b) in enumerate(zip(originals["mz.exe"], originals["zz.exe"]))
            if a != b] == [0]
    facts = {}
    refused = {"inspect-pe-certificates": "invalid_request",
               "inspect-pe-resources": "invalid_request",
               "inspect-artifact": "target_unavailable",
               "inspect-native-exports": "unsupported_target"}
    for name in originals:
        for command in commands:
            run = subprocess.run([node, "scripts/rea.mjs", command, str(work / name),
                                  "--format", "json"], cwd=repo, env=env,
                                 capture_output=True, text=True, timeout=60)
            result = json.loads(run.stdout)
            expected = refused.get(command) if name == "zz.exe" else None
            assert run.returncode == (1 if expected else 0), run.stderr
            assert result.get("code") == expected, result
            normalized = result.get("normalized_result", {})
            label = expected or normalized.get("format") or normalized["subject"]["root_format"]
            print(name, command, "exit=" + str(run.returncode), label)
            if command in commands[:2]:
                assert result["subject"]["format"] == "pe"
                assert normalized["format"] == "pe32-plus"
                facts[name, command] = {k: v for k, v in normalized.items() if k != "artifact"}
    for command in commands[:2]:
        assert facts["mz.exe", command] == facts["zz.exe", command]
    assert facts["zz.exe", "inspect-pe-imports"]["coverage"]["status"] == "complete"
    assert not (work / "package-manager-called").exists()
    for name, original in originals.items():
        assert (work / name).read_bytes() == original
PY

The comparison reproduced in two independent fixture passes, including a replay of this inline script. No target was executed and no package-manager fixture was invoked.

Expected behavior

Reject the missing MZ identity with a typed format failure, rather than returning successful PE Evidence. Preserve success for the admitted MZ control.

The import documentation promises failure for malformed PE headers. Both operation guides describe inspection of selected PE32/PE32+ images. Neither guide literally states an MZ prerequisite; the exact signature requirement is additionally grounded in REA's canonical DOS declarations and existing executable/resource/certificate admission boundaries. The load-config guide's separate fail-closed guarantee concerns directory and callback storage, rather than all header validation.

Impact and scope

P2: two static inspectors return an incorrect successful format classification for a bounded malformed-input case. Imports adds an explicit completeness claim, and both Evidence subjects identify the bytes as PE. A caller combining them with artifact inspection receives inconsistent format facts.

Preflight through inspect-artifact is a verified workaround for rejecting this exact input before invoking the specialized inspectors. No affected real-world corpus, downstream agent reliance, crash, data loss, execution or security-boundary crossing was observed. Only CLI delivery and this fixture pair were exercised; MCP and other layouts remain untested. No prior working revision was established.

REA version

Exact node scripts/rea.mjs --version output:

6.8.0

Source baseline: 65f1c447344a423fa2785847dbcea1e9a9e2454a.

Runtime and platform

Node.js v24.22.1; macOS 27.0.1; arm64. No Windows runtime or disassembler was used.

Target and artifact context

Paired 1024-byte synthetic header/section fixtures: PE header at offset 128, AMD64 machine, PE32+ optional header, one .rdata section at RVA 4096/file offset 512, and 16 absent data directories. Prefixes are MZ and ZZ. Inspector acceptance of the MZ control does not establish Windows-loader or DOS-program validity.

Interface

CLI

Earliest failure stage

Native analysis or reconstruction

Relevant output or evidence

Observed output of the inline script:

mz.exe inspect-pe-imports exit=0 pe32-plus
mz.exe inspect-pe-load-config exit=0 pe32-plus
mz.exe inspect-pe-certificates exit=0 pe32-plus
mz.exe inspect-pe-resources exit=0 pe32-plus
mz.exe inspect-artifact exit=0 pe
mz.exe inspect-native-exports exit=0 pe
zz.exe inspect-pe-imports exit=0 pe32-plus
zz.exe inspect-pe-load-config exit=0 pe32-plus
zz.exe inspect-pe-certificates exit=1 invalid_request
zz.exe inspect-pe-resources exit=1 invalid_request
zz.exe inspect-artifact exit=1 target_unavailable
zz.exe inspect-native-exports exit=1 unsupported_target

Selected fields from the successful ZZ import result's normalized_result:

{"format":"pe32-plus","coverage":{"status":"complete","reason":null,"examined_dlls":0,"imports":0,"delay_imports":0},"imphash":{"algorithm":"pefile","md5":null,"reason":"IMAGE_DIRECTORY_ENTRY_IMPORT is absent or empty."}}

Both specialized results have subject.format: "pe". Their normalized analysis fields equal their MZ controls after excluding artifact, whose path and SHA-256 correctly differ. Resources and certificates include details.issues[0].message: "Expected an MZ PE image." in their failures.

Contract sources at the baseline:

docs/pe-imports.md:3–7 establishes PE image scope; lines 65–66 promise malformed-header failure.
docs/pe-load-config.md:3–5 establishes PE image scope; lines 41–47 specify the directory/callback guarantee.
src/domain/dosMz.ts:31–37 admits only exact MZ fixed declarations. src/domain/binaryTarget.ts:124–129 requires leading MZ bytes before Windows-header parsing. src/native/pe/PeResourceLayout.ts:91–94 requires the same signature for resources/certificates.
Microsoft's PE format file-header description places the MS-DOS-compatible header/stub before the PE signature and COFF/optional headers.

Failure and reachability sources:

src/native/metadata/PeImage.ts:18–49 checks failed DOS evidence only when the independently observed Windows header is not declared.
src/domain/dosMz.ts:275–321 retains DOS validity and Windows-signature observation separately; a PE signature can be observed despite failed MZ declarations.
src/native/pe/PeImportParser.ts:153–160 and src/native/pe/PeLoadConfigParser.ts:144–151 use that shared reader. The CLI reproduction establishes public reachability.

Typed outcome or recovery expected

A nonzero exit and typed malformed-format refusal for the ZZ file, without successful PE Evidence or complete import coverage. The precise error code should follow the existing operation contract.

Analysis or suspected cause

Source-derived: the shared reader treats a declared Windows signature as sufficient admission even when the separately parsed leading DOS declaration failed. This explains the two successful public results. It does not justify requiring every legacy DOS load-module field to validate for a PE image; the missing invariant demonstrated here is the exact leading MZ signature.

Additional context

Duplicate searches covered open/closed issues and comments, plus open/closed/merged PRs, using MZ, missing/invalid/non-MZ, PE signature and both command names. Related #7403 and PR #7530 concern valid DOS-only error classification. #5168 and PR #5216 concern overlapping headers in MZ-prefixed inputs. PR #7024 discusses shared layout ownership without reporting this missing-prefix success. Closed #2343 and merged PR #2384 concern high-bit signature aliases, a separate failure from skipping MZ admission for an arbitrary ZZ prefix. No matching report was found.

Originally created by @coygeek on GitHub (Oct 28, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/7662 ### 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 Native analysis or decompilation ### Observed behavior These public commands both exit 0 for a synthetic file beginning with `ZZ` that contains PE32+ headers at the offset declared by the bytes at offset 60: ```sh node scripts/rea.mjs inspect-pe-imports "$WORK/zz.exe" --format json node scripts/rea.mjs inspect-pe-load-config "$WORK/zz.exe" --format json ``` Both return Evidence with `subject.format: "pe"` and `normalized_result.format: "pe32-plus"`. Imports reports complete coverage with zero imports. Load-config returns `tls: null`, `load_config: null` and zero examined callbacks; it has no coverage field. For the same file, resources and certificates reject the missing MZ header, artifact inspection rejects the binary format, and native exports rejects the target. An MZ-prefixed control succeeds through all six commands. The pair differs at exactly byte 0. ### Reproduction 1. Use the baseline below with its dependencies and compiled runtime present, and Node.js v24.22.1 on PATH. 2. Run the script from the checkout root. It generates the pair, isolates HOME/XDG state, places fixture package-manager launchers first on PATH, runs six static inspectors and deletes its temporary directory. ```sh python3 -I - <<'PY' from pathlib import Path import json, os, shutil, struct, subprocess, tempfile repo = Path.cwd() node = shutil.which("node") assert node is not None assert subprocess.check_output([node, "--version"], text=True).strip() == "v24.22.1" commands = ["inspect-pe-imports", "inspect-pe-load-config", "inspect-pe-certificates", "inspect-pe-resources", "inspect-artifact", "inspect-native-exports"] with tempfile.TemporaryDirectory(prefix="rea-pe-magic-") as directory: work = Path(directory) for name in ["home", "config", "cache", "data", "state", "runtime", "temp", "bin"]: (work / name).mkdir() for name in ["npx", "npm", "bun"]: launcher = work / "bin" / name launcher.write_text('#!/bin/sh\nprintf "invoked\\n" >> "' + str(work / "package-manager-called") + '"\nexit 97\n') launcher.chmod(0o755) env = {"PATH": str(work / "bin") + os.pathsep + str(Path(node).parent) + os.pathsep + os.environ.get("PATH", ""), "HOME": str(work / "home"), "TMPDIR": str(work / "temp")} for variable, name in [("XDG_CONFIG_HOME", "config"), ("XDG_CACHE_HOME", "cache"), ("XDG_DATA_HOME", "data"), ("XDG_STATE_HOME", "state"), ("XDG_RUNTIME_DIR", "runtime")]: env[variable] = str(work / name) image = bytearray(1024) def put(fmt, offset, value): struct.pack_into("<" + fmt, image, offset, value) put("I", 0x3c, 0x80) image[0x80:0x84] = bytes([0x50, 0x45, 0, 0]) for offset, value in [(0x84, 0x8664), (0x86, 1), (0x94, 240), (0x96, 0x22)]: put("H", offset, value) optional = 0x98 for fmt, offset, value in [ ("H", 0, 0x20b), ("I", 16, 0x1000), ("Q", 24, 0x140000000), ("I", 32, 0x1000), ("I", 36, 0x200), ("I", 56, 0x2000), ("I", 60, 0x200), ("H", 68, 3), ("I", 108, 16), ]: put(fmt, optional + offset, value) section = optional + 240 image[section:section + 8] = b".rdata" + bytes(2) for offset, value in [(8, 0x1000), (12, 0x1000), (16, 0x200), (20, 0x200), (36, 0x40000040)]: put("I", section + offset, value) originals = {} for name, prefix in [("mz.exe", b"MZ"), ("zz.exe", b"ZZ")]: image[:2] = prefix originals[name] = bytes(image) (work / name).write_bytes(image) assert [i for i, (a, b) in enumerate(zip(originals["mz.exe"], originals["zz.exe"])) if a != b] == [0] facts = {} refused = {"inspect-pe-certificates": "invalid_request", "inspect-pe-resources": "invalid_request", "inspect-artifact": "target_unavailable", "inspect-native-exports": "unsupported_target"} for name in originals: for command in commands: run = subprocess.run([node, "scripts/rea.mjs", command, str(work / name), "--format", "json"], cwd=repo, env=env, capture_output=True, text=True, timeout=60) result = json.loads(run.stdout) expected = refused.get(command) if name == "zz.exe" else None assert run.returncode == (1 if expected else 0), run.stderr assert result.get("code") == expected, result normalized = result.get("normalized_result", {}) label = expected or normalized.get("format") or normalized["subject"]["root_format"] print(name, command, "exit=" + str(run.returncode), label) if command in commands[:2]: assert result["subject"]["format"] == "pe" assert normalized["format"] == "pe32-plus" facts[name, command] = {k: v for k, v in normalized.items() if k != "artifact"} for command in commands[:2]: assert facts["mz.exe", command] == facts["zz.exe", command] assert facts["zz.exe", "inspect-pe-imports"]["coverage"]["status"] == "complete" assert not (work / "package-manager-called").exists() for name, original in originals.items(): assert (work / name).read_bytes() == original PY ``` The comparison reproduced in two independent fixture passes, including a replay of this inline script. No target was executed and no package-manager fixture was invoked. ### Expected behavior Reject the missing MZ identity with a typed format failure, rather than returning successful PE Evidence. Preserve success for the admitted MZ control. The import documentation promises failure for malformed PE headers. Both operation guides describe inspection of selected PE32/PE32+ images. Neither guide literally states an MZ prerequisite; the exact signature requirement is additionally grounded in REA's canonical DOS declarations and existing executable/resource/certificate admission boundaries. The load-config guide's separate fail-closed guarantee concerns directory and callback storage, rather than all header validation. ### Impact and scope P2: two static inspectors return an incorrect successful format classification for a bounded malformed-input case. Imports adds an explicit completeness claim, and both Evidence subjects identify the bytes as PE. A caller combining them with artifact inspection receives inconsistent format facts. Preflight through `inspect-artifact` is a verified workaround for rejecting this exact input before invoking the specialized inspectors. No affected real-world corpus, downstream agent reliance, crash, data loss, execution or security-boundary crossing was observed. Only CLI delivery and this fixture pair were exercised; MCP and other layouts remain untested. No prior working revision was established. ### REA version Exact `node scripts/rea.mjs --version` output: ```text 6.8.0 ``` Source baseline: `65f1c447344a423fa2785847dbcea1e9a9e2454a`. ### Runtime and platform Node.js v24.22.1; macOS 27.0.1; arm64. No Windows runtime or disassembler was used. ### Target and artifact context Paired 1024-byte synthetic header/section fixtures: PE header at offset 128, AMD64 machine, PE32+ optional header, one `.rdata` section at RVA 4096/file offset 512, and 16 absent data directories. Prefixes are MZ and ZZ. Inspector acceptance of the MZ control does not establish Windows-loader or DOS-program validity. ### Interface CLI ### Earliest failure stage Native analysis or reconstruction ### Relevant output or evidence Observed output of the inline script: ```text mz.exe inspect-pe-imports exit=0 pe32-plus mz.exe inspect-pe-load-config exit=0 pe32-plus mz.exe inspect-pe-certificates exit=0 pe32-plus mz.exe inspect-pe-resources exit=0 pe32-plus mz.exe inspect-artifact exit=0 pe mz.exe inspect-native-exports exit=0 pe zz.exe inspect-pe-imports exit=0 pe32-plus zz.exe inspect-pe-load-config exit=0 pe32-plus zz.exe inspect-pe-certificates exit=1 invalid_request zz.exe inspect-pe-resources exit=1 invalid_request zz.exe inspect-artifact exit=1 target_unavailable zz.exe inspect-native-exports exit=1 unsupported_target ``` Selected fields from the successful ZZ import result's `normalized_result`: ```json {"format":"pe32-plus","coverage":{"status":"complete","reason":null,"examined_dlls":0,"imports":0,"delay_imports":0},"imphash":{"algorithm":"pefile","md5":null,"reason":"IMAGE_DIRECTORY_ENTRY_IMPORT is absent or empty."}} ``` Both specialized results have `subject.format: "pe"`. Their normalized analysis fields equal their MZ controls after excluding `artifact`, whose path and SHA-256 correctly differ. Resources and certificates include `details.issues[0].message: "Expected an MZ PE image."` in their failures. Contract sources at the baseline: - `docs/pe-imports.md:3–7` establishes PE image scope; lines 65–66 promise malformed-header failure. - `docs/pe-load-config.md:3–5` establishes PE image scope; lines 41–47 specify the directory/callback guarantee. - `src/domain/dosMz.ts:31–37` admits only exact MZ fixed declarations. `src/domain/binaryTarget.ts:124–129` requires leading MZ bytes before Windows-header parsing. `src/native/pe/PeResourceLayout.ts:91–94` requires the same signature for resources/certificates. - Microsoft's [PE format file-header description](https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#file-headers) places the MS-DOS-compatible header/stub before the PE signature and COFF/optional headers. Failure and reachability sources: - `src/native/metadata/PeImage.ts:18–49` checks failed DOS evidence only when the independently observed Windows header is not declared. - `src/domain/dosMz.ts:275–321` retains DOS validity and Windows-signature observation separately; a PE signature can be observed despite failed MZ declarations. - `src/native/pe/PeImportParser.ts:153–160` and `src/native/pe/PeLoadConfigParser.ts:144–151` use that shared reader. The CLI reproduction establishes public reachability. ### Typed outcome or recovery expected A nonzero exit and typed malformed-format refusal for the ZZ file, without successful PE Evidence or complete import coverage. The precise error code should follow the existing operation contract. ### Analysis or suspected cause Source-derived: the shared reader treats a declared Windows signature as sufficient admission even when the separately parsed leading DOS declaration failed. This explains the two successful public results. It does not justify requiring every legacy DOS load-module field to validate for a PE image; the missing invariant demonstrated here is the exact leading MZ signature. ### Additional context Duplicate searches covered open/closed issues and comments, plus open/closed/merged PRs, using MZ, missing/invalid/non-MZ, PE signature and both command names. Related [#7403](https://github.com/morluto/rea/issues/7403) and [PR #7530](https://github.com/morluto/rea/pull/7530) concern valid DOS-only error classification. [#5168](https://github.com/morluto/rea/issues/5168) and [PR #5216](https://github.com/morluto/rea/pull/5216) concern overlapping headers in MZ-prefixed inputs. [PR #7024](https://github.com/morluto/rea/pull/7024) discusses shared layout ownership without reporting this missing-prefix success. Closed [#2343](https://github.com/morluto/rea/issues/2343) and merged [PR #2384](https://github.com/morluto/rea/pull/2384) concern high-bit signature aliases, a separate failure from skipping MZ admission for an arbitrary ZZ prefix. No matching report was found.

bsakaguchi closed this issue

2026-10-31 00:51:01 +00:00

bsakaguchi commented

2026-10-31 00:51:02 +00:00

Author

Owner

@xu91102 commented on GitHub (Oct 28, 2026):

Independently reproduced on current main 3d5c73f35c1d089807bf70e74da0e3002e08e52d, using the compiled CLI with pinned Node 24.22.1 on macOS arm64.

For both PE32 and PE32+, inspect-pe-imports and inspect-pe-load-config incorrectly exit 0 and return PE Evidence after changing only the leading MZ bytes to ZZ (4 failing cases). The matching MZ controls succeed (4 cases); changing the PE signature instead is refused with exit 1 (4 controls). All six source-file hashes remained unchanged across the 12 CLI calls. These were synthetic static inputs; no executable was run.

The shared readPeImage consumes Windows-header evidence without first admitting the fixed DOS source header. DOS load-module validity is separate: the fix should reuse the existing fixed-declaration result, rather than reject otherwise supported PE files for legacy DOS page/load declarations. I reviewed the relevant production diffs in #7024, #7530, #5216, #2384, #7013, #5510 and #1196; they address other readers, compatibility, or existing container refactoring rather than this missing admission in the two affected consumers.

Preparing a focused shared-owner fix and CLI/MCP regressions. This work is AI-assisted; full Windows execution and native-loader behavior are outside this static-inspection check.

Delivered as upstream Draft PR #7709 from xu91102:codex/pe-mz-admission (head 0534fc4ef79f9fe526b9ae8389681d1880fb4a3d). Final local evidence: 389 distinct passing tests including README checks, full static/docs/discovery checks, independent Standards/Spec review, and 12 installed CLI + 12 installed stdio MCP calls on the same immutable initial samples. The first package-verifier cleanup ambiguity remains explicitly retained/unknown; its independent repeat passed. Current-head upstream CI/Codex are separate pending checks. Human readiness declarations remain unchecked.

@xu91102 commented on GitHub (Oct 28, 2026): Independently reproduced on current main `3d5c73f35c1d089807bf70e74da0e3002e08e52d`, using the compiled CLI with pinned Node 24.22.1 on macOS arm64. For both PE32 and PE32+, `inspect-pe-imports` and `inspect-pe-load-config` incorrectly exit 0 and return PE Evidence after changing only the leading `MZ` bytes to `ZZ` (4 failing cases). The matching MZ controls succeed (4 cases); changing the PE signature instead is refused with exit 1 (4 controls). All six source-file hashes remained unchanged across the 12 CLI calls. These were synthetic static inputs; no executable was run. The shared `readPeImage` consumes Windows-header evidence without first admitting the fixed DOS source header. DOS load-module validity is separate: the fix should reuse the existing fixed-declaration result, rather than reject otherwise supported PE files for legacy DOS page/load declarations. I reviewed the relevant production diffs in #7024, #7530, #5216, #2384, #7013, #5510 and #1196; they address other readers, compatibility, or existing container refactoring rather than this missing admission in the two affected consumers. Preparing a focused shared-owner fix and CLI/MCP regressions. This work is AI-assisted; full Windows execution and native-loader behavior are outside this static-inspection check. Delivered as upstream Draft PR #7709 from `xu91102:codex/pe-mz-admission` (head `0534fc4ef79f9fe526b9ae8389681d1880fb4a3d`). Final local evidence: 389 distinct passing tests including README checks, full static/docs/discovery checks, independent Standards/Spec review, and 12 installed CLI + 12 installed stdio MCP calls on the same immutable initial samples. The first package-verifier cleanup ambiguity remains explicitly retained/unknown; its independent repeat passed. Current-head upstream CI/Codex are separate pending checks. Human readiness declarations remain unchecked.

bsakaguchi referenced this issue

2026-10-31 01:13:34 +00:00

[PR #4585] fix(browser): record dedicated worker requests through attached sessions #6322

bsakaguchi referenced this issue

2026-10-31 01:13:36 +00:00

[PR #4595] [CLOSED] fix(electron): complete wrapper removal through mutated raw-listener metadata #6328

bsakaguchi referenced this issue

2026-11-01 21:11:07 +00:00

[GH-ISSUE #5654] [Tracker] Open PRs that can't merge yet: conflicts and red CI (October 2026) #3425