Skip to content

feat(go): inspect embedded binary build metadata - #1363

Merged
morluto merged 19 commits into
morluto:mainfrom
Y0UW1SH:feat/go-build-metadata
Oct 12, 2026
Merged

morluto merged 19 commits into
morluto:mainfrom
Y0UW1SH:feat/go-build-metadata

Conversation

@Y0UW1SH

@Y0UW1SH Y0UW1SH commented Oct 9, 2026 •

Copy link
Copy Markdown
Contributor

Current head — 079b262bb

Merged main through bd74c7af2, resolved the overlapping source-map test conflicts, and preserved both addressed review threads. The Go effects wording audit now recognizes static metadata inspection. Source-map verification checks retained declaration identity and compiler-derived coordinates, and output admission follows the actual serialized representation under the existing 32 MiB budget.

All 32 current-head checks pass, including all four test shards, coverage aggregation, the required CI gate, every platform package lane, full CI, and real Go verification. GitHub reports no merge conflicts.

Local validation on the final merge: 218 focused tests, npm run check, pre-push check:fast, and real Chrome 154 / esbuild 0.25.10 source-map verification passed, including all four nested-map scenarios with verified process lineage. Earlier integration and verification notes below are historical.

Earlier integration — 01c6c4d94

Merged main through ee50ed121 and resolved the conflicts while preserving Go and WASM registration, shared schema validation and upstream's replacement binary-layout verifier. Both review threads are addressed: Go Evidence architecture now uses the canonical supported-family list, retaining MIPS; the real-Go workflow also triggers for changes to src/domain/dosMz.ts.

The MIPS regressions cover the compiled CLI and MCP session snapshot readback. The real verifier now includes a compiler-produced MIPS binary and checks Evidence subject architecture. On the final tree, Go 1.26.5 verification passed for 11 binaries / 22 public CLI and MCP cases on macOS arm64, with verified process lineage and no inspected target execution.

Validation: npm run check, npm run docs:check, pre-push check:fast, and discovery of all 909 tests passed. The initial integration passed 150 focused tests with 3 Linux-only skips; after the final main-only sync, all 43 selected CLI/MCP, catalog-schema and runtime tests passed again. Real Linux binary-layout verification was not run locally. GitHub reports no merge conflicts; current-head CI is running. Earlier CI and verification results below are historical.

Earlier hardening: 5d23c1e

The branch includes upstream main at c1efa646 and preserves the Go metadata implementation and MCP schema hardening. The newest sync adopts upstream's shared MCP helper with only the per-tool SDK options added, preserving its unknown-tool behavior and every validation assertion while minimizing future conflicts.

Recurring CI causes addressed:

  • Electron fixtures establish proven Electron module identity while retaining option, preload, and source-range assertions.
  • The cold catalog lifecycle test inherits the shared bounded, coverage-aware deadline.
  • Runtime/workflow tests pass the called tool's advertised definition to the SDK, avoiding compilation of every unrelated catalog schema. Structured responses remain validated.
  • The dedicated catalog test compiles every input/output schema. A review reproduced a false green caused by nested schema IDs leaking between tools; the validator now clears non-meta schemas after each root, including failure paths. New regressions cover successful and failed preceding compilations.

The Go inspector belongs in built-in artifact inspection: no Go runtime or third-party provider is required, and inspected binaries are never executed. Its CLI/MCP contracts, cancellation, capability inventory, session admission, and saved Evidence integration were reviewed without another actionable defect.

Validation on current head 5d23c1e: all CI jobs and real Go verification passed. The full CI run passed all four test shards and merged coverage: 7,522 tests passed / 89 skipped, across 809 discovered files (798 passed / 11 skipped). All Linux, Windows, Intel Mac, and Apple Silicon package checks passed, as did Apple end-to-end checks, static checks, build, and documentation validation.

Real Go verification passed for 10 compiler-produced binaries / 20 public CLI and MCP cases, with verified process lineage. The catalog lifecycle test completed in 4.0 seconds, and all 11 schema tests passed in CI. Local build artifacts, 20 focused tests (2 platform-specific skips), full npm run check, and independent review also passed. The PR has no merge conflicts and is ready for review.

Its immediate parent 7f5a64e passed every CI job, including all platform packages, all four test shards, and merged coverage: 7,350 tests passed / 89 skipped across 803 discovered files. Real Go verification passed for 10 compiler-produced binaries / 20 public CLI and MCP cases, with verified process lineage. The catalog lifecycle test took 3.8 seconds in CI, versus 23.6 seconds before per-tool schema compilation. The nested-ID regression failed before the fix, and all 11 schema cases then passed locally and in CI. These parent results do not substitute for the current merge's CI.

Earlier commit 9e9988b passed all four test shards and merged coverage (7,323 passed / 89 skipped). Later intermediate CI runs were superseded and canceled by branch updates, so their incomplete coverage aggregation is not a full-suite result for the current head. All validation recorded below is historical.

CI follow-up — 3370277

The real binary-layout lane timed out while expecting a memory constraint, then rejected cleanup because a Python wrapper had exec'd into the interpreter. The decoder now uses the existing parent/group/run-token ownership path for exec wrappers. Regression tests require cleanup for the owned interpreter and refuse signaling on wrong parent or run token.

The memory probe now uses a valid 32 MiB padded ELF under a 64 MiB address-space limit, with successful public CLI/MCP controls under normal limits. It still requires a typed allocation failure, exact reported limit when available, complete diagnostics, and unchanged input bytes. Production deadlines and all failure assertions remain intact.

Validation: check:fast and full npm run check passed; 61 focused tests passed across ownership, Go CLI/MCP, and session-snapshot regressions. Real bridge probes with the pinned Python packages passed on Python 3.12.3 and 3.12.14. Full local real-provider verification remains blocked by the container's procps/process-ownership boundary. GitHub's real binary-layout lane now passes on this exact head: 151 public CLI/MCP cases, 4 bootstrap boundary cases, no target execution, and verified process lineage. The fresh real Go and recorded-crash lanes also pass. The broader CI workflow is still pending; full-suite success is not yet claimed.

Earlier upstream sync — 7d35038

Merged upstream main at 0d899783 and resolved the README, CLI command inventory, MCP composition, and Vitest conflicts while preserving both Go metadata inspection and the newer upstream features. Authored Go skill guidance follows upstream's .agents/skills/ relocation.

Also reproduced and fixed an integration race: inspect_go_binary now uses the shared admitted Evidence handler, so a concurrently closing session includes the in-flight inspection in its saved snapshot. The new public MCP regression failed before the fix and passes afterward.

Validation during this sync:

  • 151 focused tests passed across 10 files, including Go reader/service/CLI/MCP, snapshot replay, PE resources, and product catalog checks.
  • npm run check, npm run docs:check, and test discovery passed; all 772 test files are discovered exactly once. Final check:fast passed after incorporating the latest Android-only upstream change.
  • Real Go 1.26.1 verification passed for 10 compiler-produced binaries and 20 public CLI/MCP cases against Go's own reader. Local process-lineage observation remains unavailable.
  • The additional JADX integration attempt had 4 passes and 29 failures blocked by this container's process-ownership ps error (fatal library error, lookup self). This is an explicit verification limitation; no real JADX result is claimed.

The merge commit's real Go lane passed. Its real binary-layout lane found the resource-limit/cleanup failure addressed by the follow-up above. Earlier verification below is historical and does not establish the current head's complete CI status.

Adds inspect_go_binary and rea inspect-go-binary PATH --json for compiler version, modules, dependency replacements and ordered build settings embedded in a selected local binary.

The built-in TypeScript reader requires no Go runtime. Inspection reads file bytes without executing the selected artifact, launching an analysis subprocess, changing the file or accessing the network. Go is used only to produce verification fixtures.

Behavior

  • Reads ELF, PE and thin Mach-O: 32/64-bit images, applicable byte orders, Go 1.18+ inline strings and historical pointer encoding.
  • Uses producer-selected sections/mappings and virtual alignment. Preserves exact source offsets, SHA-256 artifact identity, compiler bytes, framed module bytes, duplicate settings, local replacements, empty fields and unfamiliar records.
  • Go strings may contain arbitrary bytes. Undecodable go_version / module_text are null, with exact bytes in base64. Decodable module records remain available; undecodable lines are retained in unparsed_line_bytes_base64 and mark the module result incomplete.
  • Returns build_info: null when metadata is absent; absence does not prove a file is non-Go. Malformed files and unsupported containers retain distinct typed errors.
  • Integrates the target-free MCP contract, session Evidence, tool effects, CLI catalog, generated documentation inputs and skill guidance.
  • Rejects symlinks and changing file snapshots. Separate guards bound file reads to 256 MiB, embedded strings to 1 MiB, structural tables to 16 MiB and normalized reports to 8 MiB. MCP's response budget also applies.

Universal Mach-O, XCOFF and Plan 9 remain outside this reader. Embedded supply-chain claims are observed content; this tool does not authenticate them or recover functions/types.

rea inspect-go-binary ./application --json
{"name":"inspect_go_binary","arguments":{"path":"/artifacts/application"}}

Bug review

The follow-up review reproduced and fixed:

  • Rejection of valid non-UTF-8 compiler/settings strings produced by Go.
  • Validation of the unused inline pointer-width byte; pointer encoding still validates its width.
  • Acceptance of contradictory PE/Mach-O mappings, including overlaps covering only part of the metadata.
  • PE data-directory counts extending beyond the declared optional header.
  • Valid DOS/NE/LE/LX files receiving malformed-PE errors, and corrupt high-bit signatures being mistaken for old Windows formats.
  • Valid moduleless Go 1.17 binaries being rejected because their empty module header lives in zero-initialized memory outside the stored file bytes. The complete optional header must lie in declared zero-fill, without any conflicting file mapping; arbitrary unmapped pointers and compiler/string data stay strict. Empty-module source locations are documented zero-byte anchors at the original module-pointer field.
  • Initial symlink-loop (ELOOP) and overlong-path (ENAMETOOLONG) errors being misclassified as provider failures instead of invalid selected input. Post-validation replacement errors retain their artifact-changed classification.

The real verifier now clears unrelated startup-target/cache-helper settings and fixes module mode. Each CLI diagnostic regression has its own unchanged test deadline.

Earlier validation (before upstream sync)

Earlier local checks on the pre-sync follow-up tree:

  • 134 tests passed, zero failed: 130 Go tests across reader, mapping checks, module parser, provider, service, compiled CLI and MCP schemas/results, plus 4 shared stable-artifact tests. Zero-fill regressions include every supported width/byte-order layout, partial and full aliases, overflow, missing file bytes, __PAGEZERO exclusion and strict malformed pointer behavior.
  • npm run test:prepare, npm run check:ci, npm run docs:check and test discovery passed; all 705 test files are assigned exactly once. Duplication checks retain the existing threshold.
  • 10 real Go 1.26.1 binaries / 20 public CLI and MCP cases passed against Go's standard debug/buildinfo oracle: stripped ELF/PE/Mach-O, 32-bit images, big-endian ppc64, sectionless ELF, local replacement and compiler-produced arbitrary byte strings. Source bytes/digests/ranges and CLI/MCP equality are checked; inspected targets are never executed.
  • The real lane passed with deliberately unrelated startup-target/cache-helper values and ambient module mode disabled. Windows explicitly reports omission of the Unix byte-argument producer case.
  • Authentic Go 1.17.13 pointer metadata passed for 5 binaries / 10 public CLI and MCP cases: the official moduleless go, gofmt, compile and link binaries, plus a module-bearing fixture with local replacement. Results agree with Go's reader, bind source spans/digests, preserve source bytes and match across CLI/MCP. Inspected targets were never executed.
  • Independent review of the fixes and real verifier completed.
  • Additional review probes passed: 20,000 Go-generated setting records, including Unicode, escapes and byte-valued strings; 10,000 seeded parser mutations/truncations across formats, widths, byte orders and encodings, with only typed failures and byte-exact valid source ranges; and 15 additional compiler-produced binaries / 30 CLI and MCP cases. The real binaries cover modern PIE/shared-library/plugin output, legacy PIE/shared-library and PE/Mach-O output, s390x/MIPS/RISC-V, FreeBSD and Windows ARM64. These are one-off review probes, not additional committed CI tests.

Earlier CI for follow-up commit cbe413fd9b291d7a5f37c8fc78db482e3b62aec0 passed all four test shards and merged coverage: 6,417 tests passed / 89 skipped across 712 discovered files (701 passed / 11 skipped). Full-suite checks and the real Go lane passed; the latter verified 10 binaries / 20 public cases with Go 1.26.1 and process lineage. Static checks, documentation, package build, both Linux native package lanes, the Windows package/capability lane and Apple artifact E2E also passed. All 29 CI checks passed, including both Darwin package lanes.

Local process-lineage observations are explicitly unavailable on this host; the verifier does not claim OS isolation. The earlier incomplete local full-suite attempt is not counted as a passing gate.

No dependency changes, compiled fixtures, generated output, SQLite changes or unrelated fixes are included.

@Y0UW1SH
Y0UW1SH marked this pull request as ready for review October 9, 2026 20:17
@chatgpt-codex-connector

Copy link
Copy Markdown

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.
Repo admins can enable using credits for code reviews in their settings.

@Y0UW1SH
Y0UW1SH marked this pull request as draft October 9, 2026 20:33
Recognize optional module string headers in declared zero-filled memory while rejecting ambiguous and unmapped pointers. Preserve the original module-pointer field as the zero-byte source anchor.

Classify initial symlink-loop and overlong-path failures as invalid input, with CLI and MCP regressions.
@Y0UW1SH
Y0UW1SH marked this pull request as ready for review October 9, 2026 22:13
@chatgpt-codex-connector

Copy link
Copy Markdown

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.
Repo admins can enable using credits for code reviews in their settings.

Merge upstream main 0d89978, preserving Go metadata and newer CLI/MCP registrations, test projects, documentation, and relocated skill guidance.

Use the shared admitted Evidence handler for inspect_go_binary so close_binary snapshots include inspections already in flight. Add a public MCP regression that failed before the fix.

Validation during synchronization: 151 focused tests across 10 files; npm run check; npm run docs:check; all 772 test files discovered exactly once; real Go 1.26.1 verification across 10 binaries and 20 CLI/MCP cases. Final check:fast passed after incorporating the latest Android-only upstream change.

Additional JADX integration run: 4 passed, 29 blocked by this container's process-ownership ps failure (fatal library error, lookup self). No real JADX verification is claimed. Fresh CI must confirm that environment-dependent lane.
Use existing parent/group/run-token ownership for caller-selected Python launchers, which can exec through a shell or prlimit. Add cancellation regressions for the valid wrapper and wrong-parent/token cases.

Replace the timing-dependent 30,000-section memory workload with a valid 32 MiB padded ELF under a 64 MiB address-space limit. Check the same image successfully through CLI and MCP before requiring a typed memory failure, preserving the production timeout and all error assertions.

Validation: npm run check and check:fast passed; 61 focused tests passed including Go CLI/MCP and session snapshots. Real decoder probes with pinned packages passed on Python 3.12.3 and 3.12.14. The full local ELF verifier is blocked by this container's procps/process-ownership boundary; the exact pushed head requires GitHub's real-binary-layout lane.
Merge upstream c1217e7 while preserving the Go build metadata feature and newer decoder ownership/resource-test fixes.

Validation: 160 focused tests passed, including Go CLI/MCP, parser/mapping/error cases, decoder ownership and upstream JavaScript runtime regressions; build, typecheck and lint passed. All 44 branch-specific file blobs are preserved unchanged.
@siudamarcelina48-beep

Copy link
Copy Markdown

hej

Merge upstream 69fe5b6 while preserving the Go metadata feature and newer decoder fixes. Forty non-overlapping branch files remain byte-identical; four shared documentation/server files combine both sides.

Validation: fresh build, typecheck and lint passed. Final focused run: 195 tests passed, including every Go CLI/MCP test and shared artifact ownership/reconstruction boundaries. Earlier publication-boundary run: 187 passed, 3 platform/permission cases skipped.

Two FIFO process-boundary cases could not launch because this runner exposes procfs from a different PID namespace (ps: fatal library error, lookup self). Process ownership lifecycle verification remains unavailable on this host; the full suite is not claimed passing.
@CassieFox23

CassieFox23 commented Oct 10, 2026 •

Copy link
Copy Markdown
Contributor

TL;DR: I built this PR's head and ran the new Go inspector on four real Go programs from my Linux box. Every field matched a second reader I wrote in Python. The Go tests I ran on the head pass.

Edit, 11 October, 02:20 UTC: this still holds at the new head, 5d23c1e. Since eb2bb6e, only three test files changed. No Go code changed, so I did not rerun it.

Results

I ran rea inspect-go-binary --json on copies of four installed programs. I never ran any of them. I compared each report with my Python reader of the same embedded data block. The Python reader is not Go's own reader, because this box has no Go.

Tool Go version Libraries Settings Match
tailscale 1.104.1 (BSD-3-Clause) go1.27.1 61 8 all
fzf 0.74.4 (MIT) go1.26.8-X:nodwarf5 0 14 all
skopeo 1.22.3 (Apache-2.0) go1.26.8-X:nodwarf5 90 18 all
GitHub CLI 2.97.0 (MIT) go1.26.5-X:nodwarf5 166 13 all
  • "All" means five things matched. They are the Go version, the module path, the main module, the dependencies in order, and the build settings in order.
  • The module paths and main module versions are in the first fold below.
  • The header offset and the SHA-256 also matched readelf and sha256sum for each file.
  • Quoted -ldflags values came back unquoted in both readers.
  • A non-Go file (ls) gave build_info: null and exit 0.
  • Tests on the head: 133 pass in 7 files. They cover the Go image, mapping, module, provider, service, CLI and MCP tests.
  • npm ci and npm run build finished on Node 24.18.0.

Not run

  • Go's own reader. Go is not installed here.
  • The full test suite and npm run check. I ran only the Go tests above.
  • PE, Mach-O, 32-bit images and Go 1.17 binaries. All four programs are 64-bit x86 ELF.
  • A replaced dependency. None of the four has one.
  • The MCP tool by hand. The MCP test inside the 133 ran.
  • Unusual bytes in strings, as in the PR body's bug list.
  • A head merged with current main. I tested the head as it stands.

Thanks, Y0UW1SH, for the thorough write-up. It made this easy to aim at.

Module paths and main module versions
tailscale   tailscale.com/cmd/tailscale             v1.104.1
fzf         github.com/junegunn/fzf                 (none recorded)
skopeo      github.com/containers/skopeo/cmd/skopeo v0.0.0-20260916000000-92397d5ba399+dirty
GitHub CLI  github.com/cli/cli/v2/cmd/gh            (devel)
Commands
# Head built from git archive, fake HOME, npm cache and prefix
npm ci && npm run build

# Go tests on the head
node node_modules/vitest/vitest.mjs run tests/boundary/go \
  tests/boundary/mcp/goBinaryMcp.test.ts tests/acceptance/goBinaryCli.test.ts \
  src/application/go

# One report per copied program
node scripts/rea.mjs inspect-go-binary ./copy-of-program --json

# Section offset check
readelf -S -W ./copy-of-program | grep go.buildinfo

The Python reader finds the marker. It reads the two length-prefixed strings. It drops the 16-byte frame and splits the text lines.

Test setup
  • Box: Nobara 44 (Fedora 44 base), Linux 7.2.9
  • CPU: AMD Ryzen 9 5900X, 12 cores / 24 threads
  • RAM: 32 GB DDR4-3600
  • Node: 24.18.0, npm 11.16.0
  • Head: eb2bb6e, built from git archive. Its merge base with main is 69fe5b6. Main was 1b527f4.
  • Programs: tailscale 1.104.1, fzf 0.74.4, skopeo 1.22.3, GitHub CLI 2.97.0. All are Fedora or vendor packages on this box, read as copies.

🤖 Generated with Claude Code (Sonnet 5.5, verified by Opus 5.5) 🦊

Merge upstream d21132f while preserving the Go metadata implementation and decoder fixes. Only package.json and vitest.config.ts combine overlapping changes; the other 42 feature paths remain unchanged.

Reviewed native container mappings, module parsing, byte preservation, source ranges, limits, cancellation and CLI/MCP wiring; no new Go issue found.

Node 24.18.0 and npm 11.16.0: fresh build, typecheck and lint passed; 145 focused tests across 11 files passed with no failures or skips, including all Go CLI/MCP tests, stable artifact reads and decoder ownership.

The prior head passed all 11 workflows, including every CI test shard and compiler-produced ELF/PE/Mach-O CLI/MCP verification. Fresh CI must verify this merge.
@Y0UW1SH
Y0UW1SH marked this pull request as draft October 11, 2026 01:03
Declare Electron imports in option, preload override, and path-resolution fixtures after upstream began requiring proven API provenance. Retain all option and preload assertions and adjust exact source ranges for the added import line.

Use the existing bounded acceptance timeout for the cold catalog lifecycle test instead of a separate 15-second ceiling. This retains the coverage allowance and all catalog, error, and cleanup assertions without retries.

Validation: npm run check, final check:fast, formatting and diff checks passed. Source path regression and Go boundary/MCP/service checks passed. All 20 Go CLI cases and both supported-host runtime cases passed on rerun; two macOS-only cases skipped on Linux. A prior contended local run timed out once in a Go CLI diagnostic; that case passed on rerun. Electron process-boundary verification is blocked locally by procps namespace inspection and requires fresh CI.
Merge current upstream main and adopt its Electron fixture fixes while retaining the catalog lifecycle test's shared bounded acceptance deadline, including the coverage allowance.

The Go inspection implementation is unchanged. Build, full static checks, and 80 focused tests passed on the reconciled tree; two platform-specific tests were skipped.
Merge upstream while preserving the newer fork sync and its Electron fixture fixes. Validate the complete catalog in one compilation gate, with independent schema reference namespaces and regressions for unresolved references and repeated schema IDs. Workflow fixtures retain SDK and structured-response validation for their called advertised tools while avoiding repeated compilation of unrelated catalog schemas. Preserve the shared bounded catalog lifecycle deadline and coverage allowance.

Validation: pinned toolchain, build/test artifacts, npm run check, and 71 final MCP/runtime/path-resolution tests passed; two macOS-only cases skipped on Linux. JSON-shape/CDP and ASAR ownership/freshness integration passed another 27 tests. Go production files remain unchanged. Local Electron process checks are blocked by procps namespace inspection, and no Go compiler is available; fresh CI/real-Go verification is required.
Retain the newer fork sync, Go build metadata changes, and validated MCP schema hardening. Merge the current upstream native trace, Ghidra source layout, and batch address alias changes without rewriting branch history.

Validation: pinned Node/npm, build/test artifacts, 76 Ghidra adapter/MCP tests, five native trace cases and check:fast passed. The preceding hardening candidate passed full static checks, 71 final schema/runtime/path cases and 27 JSON-shape/CDP/ASAR cases, with two macOS-only skips. Go production files remain unchanged from the fork head. Real Ghidra and compiler-produced Go verification were unavailable locally and need fresh CI.
Clear Ajv's non-meta schema registry after each root, including compilation failures. Disabling root registration alone leaves nested IDs available to later tools and can let a dangling reference pass the catalog gate.

Add regressions for leakage after successful and failed compilation while retaining shared meta-schema validators. The regression failed before the fix; all 11 schema cases and full npm run check pass. Reviewed independently.
Merge current main and use its shared MCP helper, retaining only the per-tool SDK definition to avoid compiling unrelated output schemas. Preserve upstream unknown-tool handling, catalog validation, input compilation and structured-response assertions.

The nested schema isolation regressions and coverage-aware runtime deadline remain intact. Build artifacts, 20 focused tests and full static checks pass; two macOS-only cases are skipped locally. The parent passed all CI jobs and real Go verification. Independent review found no issue in the narrow conflict resolution.
@Y0UW1SH
Y0UW1SH marked this pull request as ready for review October 11, 2026 02:11
@chatgpt-codex-connector

Copy link
Copy Markdown

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.
Repo admins can enable using credits for code reviews in their settings.

@morluto

morluto commented Oct 12, 2026

Copy link
Copy Markdown
Owner

@codex

@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Oct 12, 2026 •

Copy link
Copy Markdown

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-10-12T03:42:43.261555Z 079b262 New commits
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5d23c1e7a3

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread src/application/go/GoBinaryService.ts Resolved
Comment thread .github/workflows/real-go-binary.yml Resolved
Use canonical binary architecture families for Evidence subjects, retain MIPS in CLI results and saved MCP snapshots, and cover a compiler-produced MIPS binary in the real-Go verifier. Include the shared DOS parser in the verification workflow trigger.

Merge upstream main while preserving Go and WASM registration, shared schema validation, and the replacement binary-layout verifier. Update the Go availability test to consume the named compact inventory contract.

Validation: 150 focused tests passed, 3 Linux-only skips; npm run check, docs:check and test discovery passed. Real Go 1.26.5 verification passed for 11 binaries / 22 public CLI/MCP cases on macOS arm64 with verified process lineage. Real Linux binary-layout verification was not run locally.
Merge main at ee50ed1 without conflicts. Static checks, documentation validation, and all 43 selected Go CLI/MCP, catalog-schema and runtime tests passed; test discovery covers all 909 files exactly once.
Audit the Go inspector wording as static metadata inspection. Assert retained source declaration indexes in BOM reconstruction and the compiler-derived nested-map oracle. Keep a 45,000-map admission control below the 32 MiB output budget and the 50,000-map overflow case above it with the expanded representation.

Validation: reproduced all four failing assertions, then passed 120 focused tests and the final admission suite. npm run check and real Chrome 154 / esbuild 0.25.10 source-map verification passed, including all four nested-map scenarios and verified process lineage.
Merge main at bd74c7a. Adopt the upstream serialized-output admission oracle and semantic compiler-coordinate assertions, retain source declaration identity assertions in BOM reconstruction, and preserve the Go effects wording audit.

Validation: 218 focused tests and npm run check passed. Real Chrome 154 / esbuild 0.25.10 source-map verification passed all nested-map controls with verified process lineage.
@morluto
morluto merged commit a1b5d51 into morluto:main Oct 12, 2026
30 checks passed
@github-actions github-actions Bot mentioned this pull request Oct 12, 2026
3 tasks done

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 079b262bb6

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread src/go/GoModuleText.ts
Comment on lines +200 to +204
} else if (line.startsWith("build\t")) {
const value = setting(line.slice(6));
if (value !== null) {
settings.push(value);
continue;

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Badge Clear stale module ownership before accepting replacements

When malformed module text places a valid build record (or another unrelated record) between dep/mod and =>, this branch accepts the intervening record without clearing last; the later replacement is then attached to a non-adjacent module and the build-record case is even reported as complete: true. Since a replacement belongs only to the module declaration immediately before it, clear the pending association whenever the next record is not => so malformed ordering remains explicit instead of corrupting dependency metadata.

AGENTS.md reference: AGENTS.md:L25-L25

Useful? React with 👍 / 👎.

);
assert.equal(
info.encoding,
"inline",

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Badge Verify or disclose pointer-encoding coverage

Every compiler-produced case reaches this assertion, so the real-producer lane covers only Go 1.26's inline encoding; historical pointer behavior is exercised solely by authored binary fixtures even though the public guide advertises pointer support. A regression in real Go <=1.17 pointer addresses or string layout can therefore ship while this verification remains green, so run an actual historical producer artifact through both CLI and MCP or explicitly report that coverage as unverified.

AGENTS.md reference: AGENTS.md:L48-L48

Useful? React with 👍 / 👎.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

area: native Native analysis and decompilation, including Ghidra, IDA, and Hopper analysis behavior enhancement New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants