morluto/rea
1
0
Fork 0
mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00
Code Issues 1.3k Projects Packages Wiki Activity

[GH-ISSUE #740] [Design] Roadmap: clarify investigation ownership and modularize REA capability integration #329

New issue
Open
opened 2026-10-15 18:23:56 +00:00 by bsakaguchi · 21 comments
bsakaguchi commented 2026-10-15 18:23:56 +00:00
Owner
Copy link

Originally created by @N0zoM1z0 on GitHub (Oct 6, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/740

Originally assigned to: @N0zoM1z0 on GitHub.

Before submitting

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

Decision needed

Adopt an incremental layered modularization of REA around the product direction:

REA — One MCP for reverse engineering across binaries, applications, and runtime behavior.

This roadmap covers two phases: (1) clarify investigation-record ownership and production composition/module declarations, then (2) organize source by capability domain and enforce/document the extension boundaries. Keep one distribution and existing domain-specific provider interfaces. Preserve user-visible semantics during structural increments; track optional-adapter failure isolation as a focused behavior improvement.

The product direction is agreed; this issue records the source investigation, remaining internal design choices, dependency order, and independently reviewable implementation tasks. No implementation is included in this investigation.

Context and evidence

Research baseline: main d0f3480a3cb9887499c2b188c783dd1c4db09787, 2026-10-06 UTC. This is targeted static source/caller/test inspection, not a complete import-cycle audit, benchmark, or newly executed provider/conformance run.

Pre-publication refresh: upstream main 904d03e987a6c498561b314a266202dee84b13ab adds Android/JADX via #738. Its immutable port/provider/composition/CLI/catalog changes were reviewed as an additional extension case; the original checkout remains at the detailed baseline. The refreshed catalog has 123 tools, 6 prompts, and 78 primary commands. The earlier directory counts below are explicitly for d0f3480a.

Observed source foundations: REA already has canonical named tool contracts, provider-neutral AnalysisProviderCandidate/Registry/Router, separate typed browser/runtime ports, shared CLI/MCP application workflows, a validated EvidenceLedger, and owned-process/Windows primitives. Provider IDs are extensible. Registry order is not provider priority; multiple usable deep candidates produce ambiguity. These foundations should be reused.

Observed ownership: BinarySession inherits BinarySessionRecords, which constructs both the investigation EvidenceLedger and target/profile-bound AnalysisSnapshotCache. BinarySessionPort exposes target execution/lifecycle alongside Evidence, Unknown, bundle, snapshot, and listener operations. Application/browser/runtime/process records reach that owner through the session or callbacks. close clears records even without an active target; normal target switching retains earlier Evidence, while a previous-provider cleanup failure clears it.

Observed composition: binary runtime, MCP optional loading, CLI provider construction, capability-policy flags, tool aggregation, and catalog provider/source lists are separate extension points. JavaScriptArtifactReconstruction directly selects concrete directory/ASAR readers. main loads five optional adapters with Promise.all; transport catches one aggregate load failure and supplies no optional ports. Existing tests establish core startup after aggregate failure, not per-adapter isolation.

Observed organization: counting tracked TypeScript paths while excluding only *.test.ts, domain has 241 files, all directly in its directory; application has 178, with 171 direct files. These counts include any remaining fixtures/declarations and are not complexity or memory measurements. V8 Inspector currently lives under browser. Vitest explicitly lists provider directories in the adapters project, so moves require discovery/coverage configuration updates.

Fresh Android example: #738 has a separate typed AndroidAnalysisPort and shared service, but MCP createServer and CLI registration independently construct JadxProvider; availability adds another explicit policy branch. It is not one of the five adapters in the optional loader group. Preserve Android member/target semantics, selected environment, instance-level serialization and cleanup-failure state, owned per-operation cleanup and existing JVM/worker bounds when centralizing factories. No Android execution was performed here.

Derived maintenance concern: layering is established, but investigation ownership, module declarations, concrete wiring, and capability-domain navigation need clearer boundaries. One failed optional import can disable otherwise loadable optional peers under the current aggregate path. This conditional conclusion is from source, not a new fault-injection run.

Proposed outcome: one composed investigation record service, binary-specific target/profile/snapshot ownership, shared typed production factories, statically declared module metadata, isolated optional loading, and domain-oriented directories inside the current layers.

Investigation refresh: 2026-10-07

Reviewed main e1ca412757bb01be855a66bf72006e3becd497b6 (REA 4.1.0) after IDA, firmware and NativeAOT integration. The current catalog contains 125 tools, 12 families, 80 primary CLI commands, and 18 provider descriptors. Static descriptors are not unconditional host/provider availability claims.

Confirmed foundations: application/runtime.ts already shares binary composition between CLI and MCP, including Hopper/Ghidra/IDA and lazy auxiliary providers. The migration should extend this foundation, not replace it. Android and firmware still have independently constructed providers in CLI registration and server/createServer.ts. Browser/Electron/Inspector use the five-adapter aggregate optional loader. Canonical named contracts and domain-specific typed ports should remain intact.

Current navigation evidence: tracked code paths excluding only *.test.ts give domain 244/244 direct files, application 183/176, contracts 46/46, server 55/37, browser 48/48, and scripts 117/80. Fixtures and declarations can remain in these counts. These are navigation indicators, not complexity or resource measurements. Inspector protocol ownership is distinct from browser CDP even though its adapter files currently live under browser.

Extension trace: contract aggregation, CLI registration, MCP construction, capability policy, catalog source/provider lists, test isolation/discovery, and real-verification prerequisites are separately maintained. runtime.ts currently consumes generated auxiliary provider metadata, so source-owned module declarations must avoid generated self-imports. The aggregate optional-load failure conclusion remains source-derived; this investigation does not claim a new fault-injection test.

Scripts and verification ownership are part of this roadmap. Extend T1/T5/T6/T7 acceptance with the following:

  • Maintain a capability extension map linking typed ports, application workflows, concrete factories, canonical contracts, availability facts, fixtures, documentation, and verification lanes.
  • Give each verification lane an owning capability and explicit proof level: schema/composition, package, real engine, or host-native workflow. Record prerequisites and source-owned fixtures; share runner/report primitives without introducing a custom orchestration language.
  • Organize capability-specific verifiers and fixtures together in mechanical migrations. Update npm entrypoints, CI classification, changed-test selection, test discovery/isolation/coverage, lint exceptions, generator imports and installed-package path resolution in the same PR.
  • Keep heavy real-provider lanes serial and bounded. Reuse installed engines, preserve user GUI state, and avoid eager startup, background scans, or unrelated installations.
  • Pilot one target-free typed capability and separately consolidate Android/firmware factories before broad folder moves. Demonstrate CLI/MCP parity and the appropriate packaged/real workflow for every moved path-sensitive boundary.

Review limits: this is targeted source/caller/test-configuration investigation, not a complete import-cycle audit. A separately executed Windows packaged audit covers JS/ASAR/artifacts/.NET, Node Inspector, browser scenarios and isolated setup; those results do not prove every backend or a future structural migration. In particular, native Windows Job Objects for Ghidra do not establish PTY Process Capture support.

The existing T1-T7 dependency sequence still applies. Keep this issue as the single large modularization roadmap; create implementation sub-issues when ownership and acceptance justify them. No dynamic plugin loader, multi-package rewrite, permission workflow, Evidence lifetime change, or blanket provider-platform expansion is proposed.

Refresh source references: binary composition, optional loader, MCP composition, availability policy, catalog builders, test discovery, verification lanes.

Boundary and invariants

  • One runtime/connection owns one investigation ledger; retain exact Evidence identities, detached reads, deterministic exports, provenance, Unknown optimistic revisions, and atomic Evidence-plus-Unknown mutation. No global cache, duplicate store, implicit persistence, or silent eviction.
  • Keep target/profile snapshot matching, cache exclusions and mutation invalidation in binary analysis. Snapshots do not automatically preserve independent application/browser/process records.
  • Preserve current close clearing, target-switch behavior, failed-cleanup clearing, and retained-reference expiration during initial extraction. #50 specified this behavior; #721 owns any lifetime-policy change. Extracting the record service does not close #721.
  • Preserve the exact subjects used for Unknown mutation Evidence, and best-effort post-commit notifications. Moving ownership must not fabricate a target, rewrite IDs, or turn an observer failure into a failed committed mutation.
  • Keep domain-specific typed ports for binary, artifact/application, managed, Android, browser and runtime operations. Preserve file/directory/URL/endpoint/member semantics, target-free operation, and direct selected-tool intent.
  • Maintain complete named tool contracts and SDK-converted JSON Schema validity. Do not select schemas by catalog position, truncate discovery, or accept arbitrary unknown external tool catalogs.
  • Preserve deterministic provider selection, explicit target/profile binding, no silent fallback, serialized switching, failure restoration, cancellation, owned cleanup, and actionable typed failures.
  • Keep one-shot CLI context separate from MCP connection retention. CLI/MCP share factories/workflows; a CLI call cannot resolve a different MCP connection's retained reference.
  • Setup keeps its disclosed installation plan/approval behavior. Ordinary analysis gains no grant store, repeated approval flags, prepare/execute phase, scanners, or background watchers.
  • Registration must not start every backend or install tools. Reuse existing process/Windows primitives and provider installations; preserve narrow verified provider/platform coverage.

Options and tradeoffs

  1. Keep current organization: minimal churn, but record ownership and repeated extension wiring remain.
  2. Incremental layered modularization (recommended): reuse existing behavior and interfaces, introduce narrow ports and typed source declarations, then move coherent domains in mechanical PRs. Costs are coordinated consumer/test/toolchain updates and deliberate compatibility facades.
  3. Dynamic plugin or multi-package rewrite: potential third-party distribution flexibility, but adds loading/versioning/packaging surface without an observed distribution requirement. Deferred.

Proposed owners: investigation records/Unknowns in the investigation service; active target, selected provider/profile, snapshot cache and owned client in the binary session; concrete factories in production composition; public schemas in canonical contracts; workflow semantics in application/domain modules; protocol and producer parsing in provider adapters.

Suggested organization retains domain/contracts/application layers and adds capability subdirectories. A provider namespace and dedicated composition/module directories can make concrete wiring explicit. Exact names are settled in T1. process/windows foundations remain shared lifecycle/host boundaries. Preserve existing legacy ToolKind execution/cache semantics initially; neutral reclassification is separate work requiring caller tracing.

Success criteria and open questions

This issue initially tracks work packages in one place. Create sub-issues only when implementation boundaries or independent ownership justify them.

Work package Outcome Dependencies Priority
T1 Define investigation and capability-module ownership boundaries None P1
T2 Extract investigation record ownership while preserving session behavior T1 P1
T3 Share typed production provider composition between CLI and MCP T1 P1
T4 Isolate optional adapter loading failures during MCP startup T3 P1
T5 Centralize typed capability-module declarations and derived metadata T1, T2, T3 P1
T6 Organize REA source by layer and capability domain T2, T3, T5 P2
T7 Enforce module boundaries and verify the backend extension path T1 P2

Work package completion:

  • T1: Define investigation and capability-module ownership boundaries
  • T2: Extract investigation record ownership while preserving session behavior
  • T3: Share typed production provider composition between CLI and MCP
  • T4: Isolate optional adapter loading failures during MCP startup
  • T5: Centralize typed capability-module declarations and derived metadata
  • T6: Organize REA source by layer and capability domain
  • T7: Enforce module boundaries and verify the backend extension path

Acceptance details for each work package:

T1: Define investigation and capability-module ownership boundaries
  • Document an ADR/architecture contract covering narrow typed ports, investigation versus binary lifetime, snapshot owner, explicit Evidence subjects, metadata source ownership, allowed imports, and compatibility facades.
  • Preserve current #50/#721 close/retention semantics in structural increments; do not introduce a lifetime policy or public approval/prepare step.
  • Describe a new binary backend and a new runtime implementation using existing contracts; keep differing target and authority semantics explicit.
  • Identify stable entrypoints and tool/test/generator path dependencies. No dynamic plugin distribution or new provider implementation is required.

Settle exact folder names, source declaration ownership and intended internal entrypoints. Record the contract as an ADR/architecture guide; this task does not execute the migration.

T2: Extract investigation record ownership while preserving session behavior
  • Compose one record service with narrow read/write/atomic ports; retain a BinarySession compatibility facade and current clear-on-close/failed-cleanup triggers.
  • Preserve detached reads, IDs, provider/provenance, deterministic bundles, target-specific Unknown mutation subjects, atomic recordEvidenceWithUnknown, optimistic revisions, and post-commit notifications.
  • Keep target/profile-bound snapshots, cache exclusions and invalidation at the binary boundary; preserve snapshot mismatch failures and target-filtered export.
  • Verify all five application inline/reference workflows, connection isolation, bundle transfer recovery, missing/cleared references, target switching, cancellation and cleanup failure, snapshot boundaries and Unknown rollback.
  • Preserve CLI file-backed inline behavior; no global cache, duplicate ledger, implicit persistence, new retention policy or additional permission field.
T3: Share typed production provider composition between CLI and MCP
  • Introduce an explicit production composition/factory entrypoint using the existing domain-specific port types; migrate concrete wiring incrementally.
  • Preserve deterministic deep selection, immutable target/profile binding, lazy provider startup, owned cleanup and startup/shutdown seams.
  • Maintain distinct one-shot CLI and MCP connection contexts; do not share retained state across independent commands or add a global singleton. Preserve Android provider-instance queues, cleanup-failure state, selected environment and resource bounds.
  • Verify CLI/MCP workflow parity, target-free startup without engine launch, cancellation/close, registry binding, package dispatcher, bridge path and Windows native artifact resolution.
  • Move concrete reader/backend selection out of reusable workflows only where a replaceable factory is needed; avoid interfaces for every pure helper.
T4: Isolate optional adapter loading failures during MCP startup
  • Load optional modules independently through typed factories and preserve successful ports when a peer fails.
  • Return the failed module identity and actionable availability/diagnostic reason through supported contracts; keep the complete named tool catalog advertised.
  • Inject each loader failure through production seams and demonstrate one real handler call through an unaffected recording port plus truthful failed-operation output.
  • Preserve core startup on optional failure, genuine global-startup failure, idempotent EOF/shutdown cleanup and existing cancellation semantics.
  • No retry daemon, background scan, network probe, new install step, permission prompt or eager engine launch.
T5: Centralize typed capability-module declarations and derived metadata
  • Introduce static source declarations referencing canonical contracts and precisely typed factories; integrate T2 record ports without making all operations generic JSON execution.
  • Preserve separate deep candidate selection, disjoint auxiliary ownership, typed optional port families, actual implementation provenance and derived workflow identities.
  • Reuse declarations in appropriate composition/discovery/generation consumers; dynamic host availability must remain an observation, not an unconditional metadata claim.
  • Prove presentation reordering cannot change handler/schema selection or deterministic selection policy; actual SDK-converted Draft 2020-12 input/output schemas and examples remain valid.
  • Regenerate catalogs/skill/conformance metadata from owning source; avoid declarations importing their own generated output, arbitrary external catalog passthrough, omitted tools or public schema changes disguised as refactoring.
T6: Organize REA source by layer and capability domain
  • Move one coherent domain per mechanical PR; organize inside existing layers and keep semantic fixes separate.
  • Pilot investigation records/ports, binary session/registry/snapshot, JS workflows and browser-versus-Inspector adapters, then complete remaining domains, including Android, in coordinated batches.
  • Update imports, Vitest project/isolation and coverage rules, changed-test selection, CI classification, lint exceptions, generator paths, fixtures, docs and package/provider path resolution in the same move.
  • Show moved tests are discovered once in the appropriate lane; typecheck/lint, relevant behavior cases, generated checks and package startup pass.
  • Preserve public contracts, Evidence identities, tool-kind execution/cache behavior, caller paths and provider/platform claims. Use T7 guardrails before the first move; avoid permanent broad barrels that recreate the old graph.
T7: Enforce module boundaries and verify the backend extension path
  • Prepare settled boundary/test-discovery checks before T6 moves; final closure follows T2-T6 integration.
  • Reject representative forbidden dependencies and accept deliberate composition/shared adapter utilities. Preserve named contracts and moved-test discovery with appropriate isolation.
  • Document a new deep backend and an implementation of an existing runtime port using typed factories, module declarations, exact producer/result parsing and provenance.
  • Verify canonical catalog, actual SDK schemas, CLI/MCP parity, package/bridge/native path resolution and appropriate real-provider lanes after path changes.
  • Keep source-owned fixtures and bounded host-native verification. Label recording-port success as contract/composition proof only; no IDA implementation or expanded provider/OS support is implied.

Suggested sequence: T1 -> T2/T3 -> T4/T5 -> T6 -> T7 final closure. Prepare T7 boundary/test-discovery guards before the first T6 move. Coordinate overlapping file ownership; each structural increment should be independently reviewable and reversible.

Completion criteria:

  • Investigation ownership is explicit; consumers use narrow ports while existing record lifecycle, snapshot and Unknown semantics remain compatible.
  • Shared production factories serve CLI/MCP without eager engine startup or hidden cross-call state; optional loading failures are isolated and reported truthfully.
  • Runtime/module/catalog declarations agree and preserve exact named contracts, provider provenance, effects and deterministic selection.
  • Source is organized by responsibility/domain; moved tests are discovered once with appropriate isolation; lint, coverage, changed-test selection, generation, package entrypoints and provider path resolution remain valid.
  • Representative CLI/MCP flows preserve complete results, Evidence identity and failure reasons: binary open/analyze/snapshot/close; JS analyze/reference follow-up; browser/runtime evidence; process comparison/Unknowns; bundle transfer.
  • Actual SDK input/output schemas and examples are validated after conversion; docs/product/skill/conformance metadata is generated from owning source.
  • Packaging/real-provider lanes match the changed claims. Recording-port tests establish only composition/schema proof. No new provider or OS support is inferred from directory moves.
  • No new daemon, automatic tool install, approval workflow, retained-record copy, or broad host-resource acquisition is introduced. Run heavy verification serially with bounded resources and reuse installed engines.

Remaining internal choices: exact domain folder names and stable internal entrypoints; how source declarations can be reused without erasing port types or importing their own generated output; how the compatibility facade is retired incrementally. Evidence lifetime is explicitly deferred to #721. Multiple concurrently active deep providers and external plugin distribution are outside this roadmap.

References

Related: #32 (product roadmap), #20 (completed provider-neutral foundation), #50 (current ledger lifetime), #721 (retention design), #722 / #734 (completed retained-reference capability), #723 (discovery/result repetition), #717/#718 (Android/firmware integration research motivating extension).

Refreshed Android references:

Originally created by @N0zoM1z0 on GitHub (Oct 6, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/740 Originally assigned to: @N0zoM1z0 on GitHub. ### Before submitting - [x] I searched the open and closed issues and pull requests for a related discussion. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Decision needed Adopt an incremental layered modularization of REA around the product direction: > REA — One MCP for reverse engineering across binaries, applications, and runtime behavior. This roadmap covers two phases: (1) clarify investigation-record ownership and production composition/module declarations, then (2) organize source by capability domain and enforce/document the extension boundaries. Keep one distribution and existing domain-specific provider interfaces. Preserve user-visible semantics during structural increments; track optional-adapter failure isolation as a focused behavior improvement. The product direction is agreed; this issue records the source investigation, remaining internal design choices, dependency order, and independently reviewable implementation tasks. No implementation is included in this investigation. ### Context and evidence Research baseline: main `d0f3480a3cb9887499c2b188c783dd1c4db09787`, 2026-10-06 UTC. This is targeted static source/caller/test inspection, not a complete import-cycle audit, benchmark, or newly executed provider/conformance run. Pre-publication refresh: upstream main `904d03e987a6c498561b314a266202dee84b13ab` adds Android/JADX via #738. Its immutable port/provider/composition/CLI/catalog changes were reviewed as an additional extension case; the original checkout remains at the detailed baseline. The refreshed catalog has 123 tools, 6 prompts, and 78 primary commands. The earlier directory counts below are explicitly for d0f3480a. **Observed source foundations:** REA already has canonical named tool contracts, provider-neutral AnalysisProviderCandidate/Registry/Router, separate typed browser/runtime ports, shared CLI/MCP application workflows, a validated EvidenceLedger, and owned-process/Windows primitives. Provider IDs are extensible. Registry order is not provider priority; multiple usable deep candidates produce ambiguity. These foundations should be reused. **Observed ownership:** BinarySession inherits BinarySessionRecords, which constructs both the investigation EvidenceLedger and target/profile-bound AnalysisSnapshotCache. BinarySessionPort exposes target execution/lifecycle alongside Evidence, Unknown, bundle, snapshot, and listener operations. Application/browser/runtime/process records reach that owner through the session or callbacks. close clears records even without an active target; normal target switching retains earlier Evidence, while a previous-provider cleanup failure clears it. **Observed composition:** binary runtime, MCP optional loading, CLI provider construction, capability-policy flags, tool aggregation, and catalog provider/source lists are separate extension points. JavaScriptArtifactReconstruction directly selects concrete directory/ASAR readers. main loads five optional adapters with Promise.all; transport catches one aggregate load failure and supplies no optional ports. Existing tests establish core startup after aggregate failure, not per-adapter isolation. **Observed organization:** counting tracked TypeScript paths while excluding only `*.test.ts`, domain has 241 files, all directly in its directory; application has 178, with 171 direct files. These counts include any remaining fixtures/declarations and are not complexity or memory measurements. V8 Inspector currently lives under browser. Vitest explicitly lists provider directories in the adapters project, so moves require discovery/coverage configuration updates. **Fresh Android example:** #738 has a separate typed AndroidAnalysisPort and shared service, but MCP createServer and CLI registration independently construct JadxProvider; availability adds another explicit policy branch. It is not one of the five adapters in the optional loader group. Preserve Android member/target semantics, selected environment, instance-level serialization and cleanup-failure state, owned per-operation cleanup and existing JVM/worker bounds when centralizing factories. No Android execution was performed here. **Derived maintenance concern:** layering is established, but investigation ownership, module declarations, concrete wiring, and capability-domain navigation need clearer boundaries. One failed optional import can disable otherwise loadable optional peers under the current aggregate path. This conditional conclusion is from source, not a new fault-injection run. **Proposed outcome:** one composed investigation record service, binary-specific target/profile/snapshot ownership, shared typed production factories, statically declared module metadata, isolated optional loading, and domain-oriented directories inside the current layers. ### Investigation refresh: 2026-10-07 Reviewed main `e1ca412757bb01be855a66bf72006e3becd497b6` (REA 4.1.0) after IDA, firmware and NativeAOT integration. The current catalog contains **125 tools, 12 families, 80 primary CLI commands, and 18 provider descriptors**. Static descriptors are not unconditional host/provider availability claims. **Confirmed foundations:** `application/runtime.ts` already shares binary composition between CLI and MCP, including Hopper/Ghidra/IDA and lazy auxiliary providers. The migration should extend this foundation, not replace it. Android and firmware still have independently constructed providers in CLI registration and `server/createServer.ts`. Browser/Electron/Inspector use the five-adapter aggregate optional loader. Canonical named contracts and domain-specific typed ports should remain intact. **Current navigation evidence:** tracked code paths excluding only `*.test.ts` give domain 244/244 direct files, application 183/176, contracts 46/46, server 55/37, browser 48/48, and scripts 117/80. Fixtures and declarations can remain in these counts. These are navigation indicators, not complexity or resource measurements. Inspector protocol ownership is distinct from browser CDP even though its adapter files currently live under browser. **Extension trace:** contract aggregation, CLI registration, MCP construction, capability policy, catalog source/provider lists, test isolation/discovery, and real-verification prerequisites are separately maintained. `runtime.ts` currently consumes generated auxiliary provider metadata, so source-owned module declarations must avoid generated self-imports. The aggregate optional-load failure conclusion remains source-derived; this investigation does not claim a new fault-injection test. **Scripts and verification ownership are part of this roadmap.** Extend T1/T5/T6/T7 acceptance with the following: - [ ] Maintain a capability extension map linking typed ports, application workflows, concrete factories, canonical contracts, availability facts, fixtures, documentation, and verification lanes. - [ ] Give each verification lane an owning capability and explicit proof level: schema/composition, package, real engine, or host-native workflow. Record prerequisites and source-owned fixtures; share runner/report primitives without introducing a custom orchestration language. - [ ] Organize capability-specific verifiers and fixtures together in mechanical migrations. Update npm entrypoints, CI classification, changed-test selection, test discovery/isolation/coverage, lint exceptions, generator imports and installed-package path resolution in the same PR. - [ ] Keep heavy real-provider lanes serial and bounded. Reuse installed engines, preserve user GUI state, and avoid eager startup, background scans, or unrelated installations. - [ ] Pilot one target-free typed capability and separately consolidate Android/firmware factories before broad folder moves. Demonstrate CLI/MCP parity and the appropriate packaged/real workflow for every moved path-sensitive boundary. **Review limits:** this is targeted source/caller/test-configuration investigation, not a complete import-cycle audit. A separately executed Windows packaged audit covers JS/ASAR/artifacts/.NET, Node Inspector, browser scenarios and isolated setup; those results do not prove every backend or a future structural migration. In particular, native Windows Job Objects for Ghidra do not establish PTY Process Capture support. The existing T1-T7 dependency sequence still applies. Keep this issue as the single large modularization roadmap; create implementation sub-issues when ownership and acceptance justify them. No dynamic plugin loader, multi-package rewrite, permission workflow, Evidence lifetime change, or blanket provider-platform expansion is proposed. Refresh source references: [binary composition](https://github.com/morluto/rea/blob/e1ca4127/src/application/runtime.ts), [optional loader](https://github.com/morluto/rea/blob/e1ca4127/src/main.ts), [MCP composition](https://github.com/morluto/rea/blob/e1ca4127/src/server/createServer.ts), [availability policy](https://github.com/morluto/rea/blob/e1ca4127/src/application/CapabilityInventory.ts), [catalog builders](https://github.com/morluto/rea/blob/e1ca4127/scripts/lib/catalog-builders.mjs), [test discovery](https://github.com/morluto/rea/blob/e1ca4127/vitest.config.ts), [verification lanes](https://github.com/morluto/rea/blob/e1ca4127/docs/testing.md). ### Boundary and invariants - One runtime/connection owns one investigation ledger; retain exact Evidence identities, detached reads, deterministic exports, provenance, Unknown optimistic revisions, and atomic Evidence-plus-Unknown mutation. No global cache, duplicate store, implicit persistence, or silent eviction. - Keep target/profile snapshot matching, cache exclusions and mutation invalidation in binary analysis. Snapshots do not automatically preserve independent application/browser/process records. - Preserve current close clearing, target-switch behavior, failed-cleanup clearing, and retained-reference expiration during initial extraction. #50 specified this behavior; #721 owns any lifetime-policy change. Extracting the record service does not close #721. - Preserve the exact subjects used for Unknown mutation Evidence, and best-effort post-commit notifications. Moving ownership must not fabricate a target, rewrite IDs, or turn an observer failure into a failed committed mutation. - Keep domain-specific typed ports for binary, artifact/application, managed, Android, browser and runtime operations. Preserve file/directory/URL/endpoint/member semantics, target-free operation, and direct selected-tool intent. - Maintain complete named tool contracts and SDK-converted JSON Schema validity. Do not select schemas by catalog position, truncate discovery, or accept arbitrary unknown external tool catalogs. - Preserve deterministic provider selection, explicit target/profile binding, no silent fallback, serialized switching, failure restoration, cancellation, owned cleanup, and actionable typed failures. - Keep one-shot CLI context separate from MCP connection retention. CLI/MCP share factories/workflows; a CLI call cannot resolve a different MCP connection's retained reference. - Setup keeps its disclosed installation plan/approval behavior. Ordinary analysis gains no grant store, repeated approval flags, prepare/execute phase, scanners, or background watchers. - Registration must not start every backend or install tools. Reuse existing process/Windows primitives and provider installations; preserve narrow verified provider/platform coverage. ### Options and tradeoffs 1. Keep current organization: minimal churn, but record ownership and repeated extension wiring remain. 2. Incremental layered modularization (recommended): reuse existing behavior and interfaces, introduce narrow ports and typed source declarations, then move coherent domains in mechanical PRs. Costs are coordinated consumer/test/toolchain updates and deliberate compatibility facades. 3. Dynamic plugin or multi-package rewrite: potential third-party distribution flexibility, but adds loading/versioning/packaging surface without an observed distribution requirement. Deferred. Proposed owners: investigation records/Unknowns in the investigation service; active target, selected provider/profile, snapshot cache and owned client in the binary session; concrete factories in production composition; public schemas in canonical contracts; workflow semantics in application/domain modules; protocol and producer parsing in provider adapters. Suggested organization retains domain/contracts/application layers and adds capability subdirectories. A provider namespace and dedicated composition/module directories can make concrete wiring explicit. Exact names are settled in T1. process/windows foundations remain shared lifecycle/host boundaries. Preserve existing legacy ToolKind execution/cache semantics initially; neutral reclassification is separate work requiring caller tracing. ### Success criteria and open questions <!-- ARCHITECTURE_TASKS_START --> This issue initially tracks work packages in one place. Create sub-issues only when implementation boundaries or independent ownership justify them. | Work package | Outcome | Dependencies | Priority | | --- | --- | --- | --- | | T1 | Define investigation and capability-module ownership boundaries | None | P1 | | T2 | Extract investigation record ownership while preserving session behavior | T1 | P1 | | T3 | Share typed production provider composition between CLI and MCP | T1 | P1 | | T4 | Isolate optional adapter loading failures during MCP startup | T3 | P1 | | T5 | Centralize typed capability-module declarations and derived metadata | T1, T2, T3 | P1 | | T6 | Organize REA source by layer and capability domain | T2, T3, T5 | P2 | | T7 | Enforce module boundaries and verify the backend extension path | T1 | P2 | Work package completion: - [ ] T1: Define investigation and capability-module ownership boundaries - [ ] T2: Extract investigation record ownership while preserving session behavior - [ ] T3: Share typed production provider composition between CLI and MCP - [ ] T4: Isolate optional adapter loading failures during MCP startup - [ ] T5: Centralize typed capability-module declarations and derived metadata - [ ] T6: Organize REA source by layer and capability domain - [ ] T7: Enforce module boundaries and verify the backend extension path Acceptance details for each work package: <details> <summary>T1: Define investigation and capability-module ownership boundaries</summary> - [ ] Document an ADR/architecture contract covering narrow typed ports, investigation versus binary lifetime, snapshot owner, explicit Evidence subjects, metadata source ownership, allowed imports, and compatibility facades. - [ ] Preserve current #50/#721 close/retention semantics in structural increments; do not introduce a lifetime policy or public approval/prepare step. - [ ] Describe a new binary backend and a new runtime implementation using existing contracts; keep differing target and authority semantics explicit. - [ ] Identify stable entrypoints and tool/test/generator path dependencies. No dynamic plugin distribution or new provider implementation is required. Settle exact folder names, source declaration ownership and intended internal entrypoints. Record the contract as an ADR/architecture guide; this task does not execute the migration. </details> <details> <summary>T2: Extract investigation record ownership while preserving session behavior</summary> - [ ] Compose one record service with narrow read/write/atomic ports; retain a BinarySession compatibility facade and current clear-on-close/failed-cleanup triggers. - [ ] Preserve detached reads, IDs, provider/provenance, deterministic bundles, target-specific Unknown mutation subjects, atomic recordEvidenceWithUnknown, optimistic revisions, and post-commit notifications. - [ ] Keep target/profile-bound snapshots, cache exclusions and invalidation at the binary boundary; preserve snapshot mismatch failures and target-filtered export. - [ ] Verify all five application inline/reference workflows, connection isolation, bundle transfer recovery, missing/cleared references, target switching, cancellation and cleanup failure, snapshot boundaries and Unknown rollback. - [ ] Preserve CLI file-backed inline behavior; no global cache, duplicate ledger, implicit persistence, new retention policy or additional permission field. </details> <details> <summary>T3: Share typed production provider composition between CLI and MCP</summary> - [ ] Introduce an explicit production composition/factory entrypoint using the existing domain-specific port types; migrate concrete wiring incrementally. - [ ] Preserve deterministic deep selection, immutable target/profile binding, lazy provider startup, owned cleanup and startup/shutdown seams. - [ ] Maintain distinct one-shot CLI and MCP connection contexts; do not share retained state across independent commands or add a global singleton. Preserve Android provider-instance queues, cleanup-failure state, selected environment and resource bounds. - [ ] Verify CLI/MCP workflow parity, target-free startup without engine launch, cancellation/close, registry binding, package dispatcher, bridge path and Windows native artifact resolution. - [ ] Move concrete reader/backend selection out of reusable workflows only where a replaceable factory is needed; avoid interfaces for every pure helper. </details> <details> <summary>T4: Isolate optional adapter loading failures during MCP startup</summary> - [ ] Load optional modules independently through typed factories and preserve successful ports when a peer fails. - [ ] Return the failed module identity and actionable availability/diagnostic reason through supported contracts; keep the complete named tool catalog advertised. - [ ] Inject each loader failure through production seams and demonstrate one real handler call through an unaffected recording port plus truthful failed-operation output. - [ ] Preserve core startup on optional failure, genuine global-startup failure, idempotent EOF/shutdown cleanup and existing cancellation semantics. - [ ] No retry daemon, background scan, network probe, new install step, permission prompt or eager engine launch. </details> <details> <summary>T5: Centralize typed capability-module declarations and derived metadata</summary> - [ ] Introduce static source declarations referencing canonical contracts and precisely typed factories; integrate T2 record ports without making all operations generic JSON execution. - [ ] Preserve separate deep candidate selection, disjoint auxiliary ownership, typed optional port families, actual implementation provenance and derived workflow identities. - [ ] Reuse declarations in appropriate composition/discovery/generation consumers; dynamic host availability must remain an observation, not an unconditional metadata claim. - [ ] Prove presentation reordering cannot change handler/schema selection or deterministic selection policy; actual SDK-converted Draft 2020-12 input/output schemas and examples remain valid. - [ ] Regenerate catalogs/skill/conformance metadata from owning source; avoid declarations importing their own generated output, arbitrary external catalog passthrough, omitted tools or public schema changes disguised as refactoring. </details> <details> <summary>T6: Organize REA source by layer and capability domain</summary> - [ ] Move one coherent domain per mechanical PR; organize inside existing layers and keep semantic fixes separate. - [ ] Pilot investigation records/ports, binary session/registry/snapshot, JS workflows and browser-versus-Inspector adapters, then complete remaining domains, including Android, in coordinated batches. - [ ] Update imports, Vitest project/isolation and coverage rules, changed-test selection, CI classification, lint exceptions, generator paths, fixtures, docs and package/provider path resolution in the same move. - [ ] Show moved tests are discovered once in the appropriate lane; typecheck/lint, relevant behavior cases, generated checks and package startup pass. - [ ] Preserve public contracts, Evidence identities, tool-kind execution/cache behavior, caller paths and provider/platform claims. Use T7 guardrails before the first move; avoid permanent broad barrels that recreate the old graph. </details> <details> <summary>T7: Enforce module boundaries and verify the backend extension path</summary> - [ ] Prepare settled boundary/test-discovery checks before T6 moves; final closure follows T2-T6 integration. - [ ] Reject representative forbidden dependencies and accept deliberate composition/shared adapter utilities. Preserve named contracts and moved-test discovery with appropriate isolation. - [ ] Document a new deep backend and an implementation of an existing runtime port using typed factories, module declarations, exact producer/result parsing and provenance. - [ ] Verify canonical catalog, actual SDK schemas, CLI/MCP parity, package/bridge/native path resolution and appropriate real-provider lanes after path changes. - [ ] Keep source-owned fixtures and bounded host-native verification. Label recording-port success as contract/composition proof only; no IDA implementation or expanded provider/OS support is implied. </details> <!-- ARCHITECTURE_TASKS_END --> Suggested sequence: T1 -> T2/T3 -> T4/T5 -> T6 -> T7 final closure. Prepare T7 boundary/test-discovery guards before the first T6 move. Coordinate overlapping file ownership; each structural increment should be independently reviewable and reversible. Completion criteria: - Investigation ownership is explicit; consumers use narrow ports while existing record lifecycle, snapshot and Unknown semantics remain compatible. - Shared production factories serve CLI/MCP without eager engine startup or hidden cross-call state; optional loading failures are isolated and reported truthfully. - Runtime/module/catalog declarations agree and preserve exact named contracts, provider provenance, effects and deterministic selection. - Source is organized by responsibility/domain; moved tests are discovered once with appropriate isolation; lint, coverage, changed-test selection, generation, package entrypoints and provider path resolution remain valid. - Representative CLI/MCP flows preserve complete results, Evidence identity and failure reasons: binary open/analyze/snapshot/close; JS analyze/reference follow-up; browser/runtime evidence; process comparison/Unknowns; bundle transfer. - Actual SDK input/output schemas and examples are validated after conversion; docs/product/skill/conformance metadata is generated from owning source. - Packaging/real-provider lanes match the changed claims. Recording-port tests establish only composition/schema proof. No new provider or OS support is inferred from directory moves. - No new daemon, automatic tool install, approval workflow, retained-record copy, or broad host-resource acquisition is introduced. Run heavy verification serially with bounded resources and reuse installed engines. Remaining internal choices: exact domain folder names and stable internal entrypoints; how source declarations can be reused without erasing port types or importing their own generated output; how the compatibility facade is retired incrementally. Evidence lifetime is explicitly deferred to #721. Multiple concurrently active deep providers and external plugin distribution are outside this roadmap. ### References Related: #32 (product roadmap), #20 (completed provider-neutral foundation), #50 (current ledger lifetime), #721 (retention design), #722 / #734 (completed retained-reference capability), #723 (discovery/result repetition), #717/#718 (Android/firmware integration research motivating extension). - [src/application/AnalysisProvider.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/AnalysisProvider.ts) - [src/application/AnalysisProviderRegistry.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/AnalysisProviderRegistry.ts) - [src/application/BinarySessionPort.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/BinarySessionPort.ts) - [src/application/BinarySessionRecords.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/BinarySessionRecords.ts) - [src/application/BinarySession.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/BinarySession.ts) - [src/application/AnalysisSnapshotCache.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/AnalysisSnapshotCache.ts) - [src/application/runtime.ts](https://github.com/morluto/rea/blob/d0f3480a/src/application/runtime.ts) - [src/main.ts](https://github.com/morluto/rea/blob/d0f3480a/src/main.ts) - [src/main/transport.ts](https://github.com/morluto/rea/blob/d0f3480a/src/main/transport.ts) - [src/server/createServer.ts](https://github.com/morluto/rea/blob/d0f3480a/src/server/createServer.ts) - [src/cliJavaScriptRuntimeCommands.ts](https://github.com/morluto/rea/blob/d0f3480a/src/cliJavaScriptRuntimeCommands.ts) - [src/contracts/toolContracts.ts](https://github.com/morluto/rea/blob/d0f3480a/src/contracts/toolContracts.ts) - [scripts/lib/catalog-builders.mjs](https://github.com/morluto/rea/blob/d0f3480a/scripts/lib/catalog-builders.mjs) - [scripts/lib/catalog-core.mjs](https://github.com/morluto/rea/blob/d0f3480a/scripts/lib/catalog-core.mjs) - [vitest.config.ts](https://github.com/morluto/rea/blob/d0f3480a/vitest.config.ts) - [.oxlintrc.json](https://github.com/morluto/rea/blob/d0f3480a/.oxlintrc.json) - [tests/boundary/mcp/mainErrors.test.ts](https://github.com/morluto/rea/blob/d0f3480a/tests/boundary/mcp/mainErrors.test.ts) - [tests/boundary/mcp/retainedApplicationEvidenceMcp.test.ts](https://github.com/morluto/rea/blob/d0f3480a/tests/boundary/mcp/retainedApplicationEvidenceMcp.test.ts) Refreshed Android references: - [Android port](https://github.com/morluto/rea/blob/904d03e9/src/application/AndroidAnalysisPort.ts) - [JADX provider](https://github.com/morluto/rea/blob/904d03e9/src/android/JadxProvider.ts) - [MCP default construction](https://github.com/morluto/rea/blob/904d03e9/src/server/createServer.ts) - [CLI construction](https://github.com/morluto/rea/blob/904d03e9/src/cli/androidCommands.ts) - [Refreshed catalog](https://github.com/morluto/rea/blob/904d03e9/docs/product-catalog.json)
bsakaguchi commented 2026-10-15 18:23:57 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Incremental implementation has started following the decision to migrate concrete capabilities before generalizing shared declarations.

Merged: #819, after all CI checks passed. This adds a working ownership/migration guide, inward import checks, and a check of actual Vitest discovery. It also relocates one unchanged contract input schema to domain and moves a CLI inventory assertion into its boundary lane. The package verification passed separately.

T1/T7 foundations are in place, but their full acceptance remains open. The next concrete pilot is Android/firmware production construction using the existing typed ports, preserving instance queues, selected environment and cleanup-failure state. T2 record extraction and T5 declarations will follow observed caller needs; no universal provider interface is being frozen upfront.

<!-- gh-comment-id:6030081105 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Incremental implementation has started following the decision to migrate concrete capabilities before generalizing shared declarations. Merged: #819, after all CI checks passed. This adds a working ownership/migration guide, inward import checks, and a check of actual Vitest discovery. It also relocates one unchanged contract input schema to domain and moves a CLI inventory assertion into its boundary lane. The package verification passed separately. T1/T7 foundations are in place, but their full acceptance remains open. The next concrete pilot is Android/firmware production construction using the existing typed ports, preserving instance queues, selected environment and cleanup-failure state. T2 record extraction and T5 declarations will follow observed caller needs; no universal provider interface is being frozen upfront.
bsakaguchi commented 2026-10-15 18:23:57 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Incremental implementation: PR #838 is ready for review for the T3 optional-factory pilot and T4 independent loading.

  • Five existing typed observation factories are shared by CLI/MCP; no universal provider contract or plugin manifest is introduced.
  • Each optional import/constructor failure retains healthy peers and is reported in session availability and the existing typed tool error. All 126 tools stay advertised. Passive/active Electron are independent; static JS/reconciliation still execute.
  • Production loading/startup fault injection covers each adapter and total failure with actual SDK calls, healthy Evidence retention, configured-policy precedence, malformed input and fresh connection state.
  • Relevant SDK/schema/availability/startup/guard and CLI cases pass. All 483 test files are discovered exactly once; static/generated checks pass.
  • Real Linux Node Inspector passes eight CLI/MCP fixtures. Full installed package verification passes; sampled MCP peak RSS is approximately 426 MiB and startup to tools/list is approximately 1.97 seconds.

CI is pending. Real browser/Electron, Hopper and Ghidra verification was not run locally. T2 record ownership and T5 metadata remain the next stages; T6 moves follow those concrete migrations. The roadmap and #721 remain open.

<!-- gh-comment-id:6030405848 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Incremental implementation: PR #838 is ready for review for the T3 optional-factory pilot and T4 independent loading. - Five existing typed observation factories are shared by CLI/MCP; no universal provider contract or plugin manifest is introduced. - Each optional import/constructor failure retains healthy peers and is reported in session availability and the existing typed tool error. All 126 tools stay advertised. Passive/active Electron are independent; static JS/reconciliation still execute. - Production loading/startup fault injection covers each adapter and total failure with actual SDK calls, healthy Evidence retention, configured-policy precedence, malformed input and fresh connection state. - Relevant SDK/schema/availability/startup/guard and CLI cases pass. All 483 test files are discovered exactly once; static/generated checks pass. - Real Linux Node Inspector passes eight CLI/MCP fixtures. Full installed package verification passes; sampled MCP peak RSS is approximately 426 MiB and startup to tools/list is approximately 1.97 seconds. CI is pending. Real browser/Electron, Hopper and Ghidra verification was not run locally. T2 record ownership and T5 metadata remain the next stages; T6 moves follow those concrete migrations. The roadmap and #721 remain open.
bsakaguchi commented 2026-10-15 18:23:57 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Investigation-record ownership pilot merged in #845 after all 20 CI checks passed, including real browser, Apple artifacts, Linux/Windows Inspector and three-platform package verification.

One composed InvestigationRecords owner reuses the existing EvidenceLedger. Consumers now use narrow read/write/atomic and Unknown ports. BinarySessionRecords retains binary snapshot ownership and its compatible facade. Explicit Unknown target subjects, target-free atomic mutation, detached reads, IDs, import deltas and post-commit notification ordering are preserved. Close and failed-cleanup clearing remain unchanged; #721 remains open.

Local verification: 8 new ownership/rollback/observer cases plus existing ledger, session, retained-reference, snapshot, Unknown and capture/workflow boundaries; generated/static checks; unique discovery of 490 test files; real Linux Node Inspector; full installed CLI/MCP package verification. Recording ports establish composition coverage only; real Hopper/Ghidra were not run for this extraction.

The next increment pilots adapter-owned auxiliary metadata and named contract binding. The overall T5/T6/T7 roadmap remains open; no universal provider contract or new retention policy is introduced.

<!-- gh-comment-id:6030748988 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Investigation-record ownership pilot merged in #845 after all 20 CI checks passed, including real browser, Apple artifacts, Linux/Windows Inspector and three-platform package verification. One composed InvestigationRecords owner reuses the existing EvidenceLedger. Consumers now use narrow read/write/atomic and Unknown ports. BinarySessionRecords retains binary snapshot ownership and its compatible facade. Explicit Unknown target subjects, target-free atomic mutation, detached reads, IDs, import deltas and post-commit notification ordering are preserved. Close and failed-cleanup clearing remain unchanged; #721 remains open. Local verification: 8 new ownership/rollback/observer cases plus existing ledger, session, retained-reference, snapshot, Unknown and capture/workflow boundaries; generated/static checks; unique discovery of 490 test files; real Linux Node Inspector; full installed CLI/MCP package verification. Recording ports establish composition coverage only; real Hopper/Ghidra were not run for this extraction. The next increment pilots adapter-owned auxiliary metadata and named contract binding. The overall T5/T6/T7 roadmap remains open; no universal provider contract or new retention policy is introduced.
bsakaguchi commented 2026-10-15 18:23:57 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Auxiliary source metadata and named contract binding merged in #853 after all 19 CI checks passed, including Apple artifact, Linux/Windows Inspector and three-platform package verification.

Artifact, macOS native and managed static implementations now share adapter-owned immutable metadata with a concrete typed composition declaration and catalog generation. Runtime discovery and binary operation-kind routing consume canonical source facts rather than their generated artifact. The generated catalog is unchanged; host restrictions, effects, limitations, provenance and native dispatch coverage are preserved. Deep candidate selection and five observation port families remain distinct.

All four positional observation registrars now use toolContract(name). An isolated compiled-process SDK regression reverses presentation arrays. Before the fix, compare_web_screenshots dispatched list_browser_targets; afterward both presentations preserve schemas and handler meaning.

Verification: 112 focused pilot/existing boundary cases; five static checks; unchanged generated metadata; 494 test files discovered once; eight real Linux Node Inspector fixtures; full installed CLI/MCP package verification (126 tools, lifecycle/update/setup recovery). Startup to tools/list was 2486 ms with sampled peak RSS approximately 432 MiB. Real Hopper/Ghidra were not run locally for this metadata extraction.

Next: resolve source ownership accurately in module-boundary guards before capability folder moves. A read-only source audit found test overrides masking six provider imports in four tests; preserve their assertions/fixtures while placing producer-dependent checks in the proper lane. Then perform the investigation-record mechanical move. T5 remains a concrete pilot; the broader T6/T7 extension map and coordinated domain migrations remain open.

<!-- gh-comment-id:6030983516 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Auxiliary source metadata and named contract binding merged in #853 after all 19 CI checks passed, including Apple artifact, Linux/Windows Inspector and three-platform package verification. Artifact, macOS native and managed static implementations now share adapter-owned immutable metadata with a concrete typed composition declaration and catalog generation. Runtime discovery and binary operation-kind routing consume canonical source facts rather than their generated artifact. The generated catalog is unchanged; host restrictions, effects, limitations, provenance and native dispatch coverage are preserved. Deep candidate selection and five observation port families remain distinct. All four positional observation registrars now use toolContract(name). An isolated compiled-process SDK regression reverses presentation arrays. Before the fix, compare_web_screenshots dispatched list_browser_targets; afterward both presentations preserve schemas and handler meaning. Verification: 112 focused pilot/existing boundary cases; five static checks; unchanged generated metadata; 494 test files discovered once; eight real Linux Node Inspector fixtures; full installed CLI/MCP package verification (126 tools, lifecycle/update/setup recovery). Startup to tools/list was 2486 ms with sampled peak RSS approximately 432 MiB. Real Hopper/Ghidra were not run locally for this metadata extraction. Next: resolve source ownership accurately in module-boundary guards before capability folder moves. A read-only source audit found test overrides masking six provider imports in four tests; preserve their assertions/fixtures while placing producer-dependent checks in the proper lane. Then perform the investigation-record mechanical move. T5 remains a concrete pilot; the broader T6/T7 extension map and coordinated domain migrations remain open.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Resolved source-boundary prerequisite merged in #862 after all 21 CI checks passed, including full coverage/timing, real browser/recovery, Apple artifacts, Linux/Windows Inspector and three-platform package verification.

The development gate parses actual source imports and checks normalized local ownership before T6 folder moves. Nested pure capability directories remain allowed; provider counterparts remain forbidden. The exact production binary-runtime exception and shared adapter utilities are preserved. Existing Babel dependencies, Git-owned source discovery and static-cache inputs are reused; no universal provider contract or runtime permission is added.

Five masked imports in three producer-dependent tests were exposed by the actual source scan. Their assertions and fixtures were moved unchanged into boundary lanes. After resolving a newly merged JavaScript recovery configuration conflict, 54 guard probes, 9 moved behavior cases and 11 affected recovery cases passed. Static/generated checks and unique discovery of all 502 tests passed. Compiled original/reversed MCP presentation remained correct.

Extra local production-entrypoint checks intermittently hit their unchanged deadlines under bounded execution on the loaded host; this is disclosed in the PR. Each case also completed within the original deadline in isolated runs. No production behavior or deadline was changed, and the complete CI test/acceptance checks passed before merge.

Next: a mechanical investigation ledger/Unknown helper move, followed by coherent capability-owned adapter/fixture/verifier migrations. T6 and final T7 guidance remain open; #721 remains separate.

<!-- gh-comment-id:6031293917 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Resolved source-boundary prerequisite merged in #862 after all 21 CI checks passed, including full coverage/timing, real browser/recovery, Apple artifacts, Linux/Windows Inspector and three-platform package verification. The development gate parses actual source imports and checks normalized local ownership before T6 folder moves. Nested pure capability directories remain allowed; provider counterparts remain forbidden. The exact production binary-runtime exception and shared adapter utilities are preserved. Existing Babel dependencies, Git-owned source discovery and static-cache inputs are reused; no universal provider contract or runtime permission is added. Five masked imports in three producer-dependent tests were exposed by the actual source scan. Their assertions and fixtures were moved unchanged into boundary lanes. After resolving a newly merged JavaScript recovery configuration conflict, 54 guard probes, 9 moved behavior cases and 11 affected recovery cases passed. Static/generated checks and unique discovery of all 502 tests passed. Compiled original/reversed MCP presentation remained correct. Extra local production-entrypoint checks intermittently hit their unchanged deadlines under bounded execution on the loaded host; this is disclosed in the PR. Each case also completed within the original deadline in isolated runs. No production behavior or deadline was changed, and the complete CI test/acceptance checks passed before merge. Next: a mechanical investigation ledger/Unknown helper move, followed by coherent capability-owned adapter/fixture/verifier migrations. T6 and final T7 guidance remain open; #721 remains separate.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

First T6 investigation source move merged in #867 after all 19 CI checks passed, including full coverage/timing, Apple artifact, Linux/Windows Inspector and three-platform package verification.

EvidenceLedger, UnknownEvidence and the ledger's two original tests now live beside InvestigationRecords and its narrow ports. All import consumers follow the new paths. Exact before/after comparison confirmed unchanged implementation bodies and assertions; there is no compatibility barrel, second store or lifecycle change. Snapshot/cache ownership stays binary-specific; #721 remains separate.

Local validation: 48 source/composition and 17 filesystem/MCP/acceptance cases passed, including large-record retention, atomic Unknown/CAS rollback, detached reads, observer ordering, retained references, bundle transfer and target-free/session workflows. Static/generated checks and unique discovery of all 502 tests passed. Full installed package CLI/MCP verification passed (127 tools, Evidence transfer, lifecycle/setup recovery/update), with startup to tools/list approximately 2.01 seconds and sampled MCP peak RSS approximately 431MiB. The existing large-record suite was run serially and peaked at approximately 1.4GiB RSS. Windows D was not used.

Next: separate Inspector adapter ownership from browser CDP and migrate its fixtures and real verification entrypoint together. Shared adapter transport/location helpers remain explicit; source contracts and distinct typed ports stay authoritative. Other T6 domains and final T7 extension guidance remain open.

<!-- gh-comment-id:6031494988 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): First T6 investigation source move merged in #867 after all 19 CI checks passed, including full coverage/timing, Apple artifact, Linux/Windows Inspector and three-platform package verification. EvidenceLedger, UnknownEvidence and the ledger's two original tests now live beside InvestigationRecords and its narrow ports. All import consumers follow the new paths. Exact before/after comparison confirmed unchanged implementation bodies and assertions; there is no compatibility barrel, second store or lifecycle change. Snapshot/cache ownership stays binary-specific; #721 remains separate. Local validation: 48 source/composition and 17 filesystem/MCP/acceptance cases passed, including large-record retention, atomic Unknown/CAS rollback, detached reads, observer ordering, retained references, bundle transfer and target-free/session workflows. Static/generated checks and unique discovery of all 502 tests passed. Full installed package CLI/MCP verification passed (127 tools, Evidence transfer, lifecycle/setup recovery/update), with startup to tools/list approximately 2.01 seconds and sampled MCP peak RSS approximately 431MiB. The existing large-record suite was run serially and peaked at approximately 1.4GiB RSS. Windows D was not used. Next: separate Inspector adapter ownership from browser CDP and migrate its fixtures and real verification entrypoint together. Shared adapter transport/location helpers remain explicit; source contracts and distinct typed ports stay authoritative. Other T6 domains and final T7 extension guidance remain open.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Inspector source-layout migration merged in #869. The adapter/identity, loopback producer fixture, real Node fixture, verifier and producer-boundary tests now have explicit Inspector ownership. Existing typed ports, CLI/MCP names, evidence, shared CDP helpers and passive authority are preserved.

Verification: 111 relevant cases, eight real Linux Inspector filename workflows, five static tasks, unchanged generated documents, all 502 tests discovered once, and full installed-package workflows (127 tools). All 21 CI checks passed, including real Windows Inspector, platform packages and the complete real-browser lane. The first browser CI run reported popup cleanup failure; unchanged cleanup code and the exact local real popup workflow were investigated before one failed-job rerun passed. The full local browser lane separately failed on available-Chromium screenshot dimensions and was not counted as a passing proof. Details remain in the PR.

Heavy local lanes stayed serial, two-CPU-affinity and heap-bounded; existing engines reused, no Windows host writes. Next T6 batch: Android layer/verification ownership; do not generalize differing provider lifecycles into a universal interface.

<!-- gh-comment-id:6031909716 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Inspector source-layout migration merged in #869. The adapter/identity, loopback producer fixture, real Node fixture, verifier and producer-boundary tests now have explicit Inspector ownership. Existing typed ports, CLI/MCP names, evidence, shared CDP helpers and passive authority are preserved. Verification: 111 relevant cases, eight real Linux Inspector filename workflows, five static tasks, unchanged generated documents, all 502 tests discovered once, and full installed-package workflows (127 tools). All 21 CI checks passed, including real Windows Inspector, platform packages and the complete real-browser lane. The first browser CI run reported popup cleanup failure; unchanged cleanup code and the exact local real popup workflow were investigated before one failed-job rerun passed. The full local browser lane separately failed on available-Chromium screenshot dimensions and was not counted as a passing proof. Details remain in the PR. Heavy local lanes stayed serial, two-CPU-affinity and heap-bounded; existing engines reused, no Windows host writes. Next T6 batch: Android layer/verification ownership; do not generalize differing provider lifecycles into a universal interface.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Android layer and verification migration merged in #873. Its three application files, two pure domain files, named contracts and inventory-projection composition test now have capability ownership. Real verifier/cancellation helper and explicit downloader/immutable manifest are grouped under owning Android directories; both CLI/MCP, factory, producer imports and generator follow the new paths. Existing command names, repository fixture default, Evidence, selected environment and lifecycle/resource limits are preserved.

Verification: unchanged implementation/assertion ASTs for 27 affected TypeScript files; byte-identical fixture manifest; 102 meaningful contract/producer/queue/cancellation/cleanup/SDK/projection/layer cases; five static tasks; unchanged generated outputs; all 504 tests discovered once; full isolated installed-package workflows (129 tools). Startup sample 4241.98ms; sampled MCP peak RSS ~414MiB. All 21 CI checks passed, including Windows capability/package, platform installs, coverage, browser and Linux/Windows Inspector. Real JADX was not run locally because fixed APK/JAR assets were unavailable; synthetic success is not represented as engine proof. No engine installs or Windows host writes.

Next coherent T6 batch: firmware layer/verifier/fixture ownership. No universal provider contract or lifecycle introduced.

<!-- gh-comment-id:6032110844 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Android layer and verification migration merged in #873. Its three application files, two pure domain files, named contracts and inventory-projection composition test now have capability ownership. Real verifier/cancellation helper and explicit downloader/immutable manifest are grouped under owning Android directories; both CLI/MCP, factory, producer imports and generator follow the new paths. Existing command names, repository fixture default, Evidence, selected environment and lifecycle/resource limits are preserved. Verification: unchanged implementation/assertion ASTs for 27 affected TypeScript files; byte-identical fixture manifest; 102 meaningful contract/producer/queue/cancellation/cleanup/SDK/projection/layer cases; five static tasks; unchanged generated outputs; all 504 tests discovered once; full isolated installed-package workflows (129 tools). Startup sample 4241.98ms; sampled MCP peak RSS ~414MiB. All 21 CI checks passed, including Windows capability/package, platform installs, coverage, browser and Linux/Windows Inspector. Real JADX was not run locally because fixed APK/JAR assets were unavailable; synthetic success is not represented as engine proof. No engine installs or Windows host writes. Next coherent T6 batch: firmware layer/verifier/fixture ownership. No universal provider contract or lifecycle introduced.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Firmware T6 source/verification batch merged in #878 after all 21 CI checks passed, including Windows capability/package and real-tool lanes selected by CI.

Four firmware layer files and three verification/fixture producers now have capability-owned locations. Both caller adapters, typed factory, generator and existing npm names were migrated together. All 17 affected TypeScript implementation/assertion bodies are unchanged apart from local imports; Python producer is byte-identical.

Local proof: five static gates, fresh build/generated documents, 64 exact producer/contract/SDK/compiled cases, all 506 files discovered once, actual relocated fixture generation with selected and outside-repository default directories, and full installed package (129 tools, Evidence/lifecycle/setup/update). Package startup to tools/list 4137.51ms; sampled MCP peak ~452MiB under serial two-CPU bounds.

No new engine/platform claim: complete real Binwalk/Unblob was not run locally because the supported tool pair was unavailable. Fixture generation and fake producer tests retain their narrower proof levels. No engine installation or Windows host disk writes.

Next: mechanically group binary session/selection/snapshot ownership after refreshing main. Shared cross-domain target parsing and interface types stay shared; no universal provider contract or lifecycle change. Roadmap and retention #721 remain open.

<!-- gh-comment-id:6032548526 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Firmware T6 source/verification batch merged in #878 after all 21 CI checks passed, including Windows capability/package and real-tool lanes selected by CI. Four firmware layer files and three verification/fixture producers now have capability-owned locations. Both caller adapters, typed factory, generator and existing npm names were migrated together. All 17 affected TypeScript implementation/assertion bodies are unchanged apart from local imports; Python producer is byte-identical. Local proof: five static gates, fresh build/generated documents, 64 exact producer/contract/SDK/compiled cases, all 506 files discovered once, actual relocated fixture generation with selected and outside-repository default directories, and full installed package (129 tools, Evidence/lifecycle/setup/update). Package startup to tools/list 4137.51ms; sampled MCP peak ~452MiB under serial two-CPU bounds. No new engine/platform claim: complete real Binwalk/Unblob was not run locally because the supported tool pair was unavailable. Fixture generation and fake producer tests retain their narrower proof levels. No engine installation or Windows host disk writes. Next: mechanically group binary session/selection/snapshot ownership after refreshing main. Shared cross-domain target parsing and interface types stay shared; no universal provider contract or lifecycle change. Roadmap and retention #721 remain open.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Binary application owner pilot merged in #886 after all 21 CI checks passed, including Windows capability/package.

Nineteen session, registry/evaluation, routing/composition, lazy-client, snapshot/persistence and cancellation/cleanup files now live under application/binary. InvestigationRecords remains independent; shared cross-domain target parsing/types and the exact temporary runtime composition entrypoint retain their deliberate owners. No lifecycle, cache policy or provider-selection semantics changed.

Local proof: all 56 affected TypeScript implementation/assertion ASTs and mapped import owners preserved; five static gates; fresh compiled paths and generated outputs; 96 cases in 23 files; 508 files discovered once and development selection checked; full installed package (129 tools, six prompts, Evidence/lifecycle/setup/update). Startup to tools/list 2080.38ms; sampled MCP peak ~460MiB.

Actual isolated Linux Ghidra 12.1.4 CLI inspect and MCP open/list/decompile/read-bytes/mapping/close passed with original-byte oracle, unchanged target digest, verified empty runtime, preserved caller files and no owned process remaining. Sampled family peak ~1.08GiB under two-CPU bounds. This is narrower than complete canonical real-provider conformance; no new real Hopper/IDA/Windows-engine claim.

Next: remove the remaining deep-provider source/generated-catalog self-dependency in a separate source-declaration increment, with canonical name joins and exact capability comparisons. Source/folder migration remains incremental; roadmap #740 and retention #721 stay open.

<!-- gh-comment-id:6032817129 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Binary application owner pilot merged in #886 after all 21 CI checks passed, including Windows capability/package. Nineteen session, registry/evaluation, routing/composition, lazy-client, snapshot/persistence and cancellation/cleanup files now live under application/binary. InvestigationRecords remains independent; shared cross-domain target parsing/types and the exact temporary runtime composition entrypoint retain their deliberate owners. No lifecycle, cache policy or provider-selection semantics changed. Local proof: all 56 affected TypeScript implementation/assertion ASTs and mapped import owners preserved; five static gates; fresh compiled paths and generated outputs; 96 cases in 23 files; 508 files discovered once and development selection checked; full installed package (129 tools, six prompts, Evidence/lifecycle/setup/update). Startup to tools/list 2080.38ms; sampled MCP peak ~460MiB. Actual isolated Linux Ghidra 12.1.4 CLI inspect and MCP open/list/decompile/read-bytes/mapping/close passed with original-byte oracle, unchanged target digest, verified empty runtime, preserved caller files and no owned process remaining. Sampled family peak ~1.08GiB under two-CPU bounds. This is narrower than complete canonical real-provider conformance; no new real Hopper/IDA/Windows-engine claim. Next: remove the remaining deep-provider source/generated-catalog self-dependency in a separate source-declaration increment, with canonical name joins and exact capability comparisons. Source/folder migration remains incremental; roadmap #740 and retention #721 stay open.
bsakaguchi commented 2026-10-15 18:23:58 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

T5/T7 source-declaration increment merged in #892 after all 19 CI checks passed.

Hopper, Ghidra and IDA now declare frozen operation inventories in their own capability modules. The generator joins those names to canonical contracts, with exact provider effects, limitations, Windows restrictions and IDA lifecycle differences preserved. A resolved-import guard prevents providers from consuming their derived MCP catalog; the existing application cache remains an explicit consumer.

Executed locally: five static gates, fresh generated-document/build checks, 162 cases in 18 files, unique discovery of 518 files, exact before/after capability JSON for Hopper/Ghidra and four IDA configurations, compiled import-closure inspection, and complete installed-package verification (130 tools, six prompts). A bounded real Linux Ghidra 12.1.4 CLI/MCP workflow also passed byte-oracle, identity and cleanup checks; real Hopper, IDA and Windows engines were not exercised locally for this increment. CI platform checks passed.

Next: a mechanical JavaScript application-owner migration with its verifier/fixture entrypoints, import-owner and URL-root checks, actual relocated-script runs and package verification. T6 and final extension documentation remain in progress; this increment does not close the roadmap.

<!-- gh-comment-id:6033354188 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): T5/T7 source-declaration increment merged in #892 after all 19 CI checks passed. Hopper, Ghidra and IDA now declare frozen operation inventories in their own capability modules. The generator joins those names to canonical contracts, with exact provider effects, limitations, Windows restrictions and IDA lifecycle differences preserved. A resolved-import guard prevents providers from consuming their derived MCP catalog; the existing application cache remains an explicit consumer. Executed locally: five static gates, fresh generated-document/build checks, 162 cases in 18 files, unique discovery of 518 files, exact before/after capability JSON for Hopper/Ghidra and four IDA configurations, compiled import-closure inspection, and complete installed-package verification (130 tools, six prompts). A bounded real Linux Ghidra 12.1.4 CLI/MCP workflow also passed byte-oracle, identity and cleanup checks; real Hopper, IDA and Windows engines were not exercised locally for this increment. CI platform checks passed. Next: a mechanical JavaScript application-owner migration with its verifier/fixture entrypoints, import-owner and URL-root checks, actual relocated-script runs and package verification. T6 and final extension documentation remain in progress; this increment does not close the roadmap.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

T6 JavaScript application-owner migration merged in #896 after all 21 CI checks passed.

The existing JavaScript/Electron workflows and observation/recovery ports now live in src/application/javascript/. Four JavaScript verifier entrypoints live in scripts/verify/javascript/; recovery fixture compilation lives beside its unchanged source fixtures. npm commands, compiled managed consumers, existing invocation tests and owning CI path filters migrated together.

Executed local proof: exact body/import-owner/file-URL comparison for 126 affected TS/MJS modules, all 71 moves accounted for, five static gates, fresh generated documents, 54 new compiled module paths with old paths absent, 517 cases in 48 files, all 518 files discovered once, eight real Linux Inspector filename cases through CLI/MCP, and full installed-package verification (130 tools, six prompts). Actual relocated workflow/reconciliation entrypoints passed; recovery prerequisite imports were also checked from an unrelated working directory.

Hosted CI additionally passed real JavaScript recovery using the relocated compiler/default entrypoint, real browser verification, macOS package/Apple artifacts and Windows package/native workflows. Local recording-port tests were not treated as engine proof.

The concrete directory/ASAR reader boundary remains intact for a separately traced refactor. Next is a focused native CI increment for Linux arm64/aarch64, Intel macOS and real Inspector coverage across the existing mainstream native hosts; T6 and final extension documentation remain open.

<!-- gh-comment-id:6033730508 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): T6 JavaScript application-owner migration merged in #896 after all 21 CI checks passed. The existing JavaScript/Electron workflows and observation/recovery ports now live in `src/application/javascript/`. Four JavaScript verifier entrypoints live in `scripts/verify/javascript/`; recovery fixture compilation lives beside its unchanged source fixtures. npm commands, compiled managed consumers, existing invocation tests and owning CI path filters migrated together. Executed local proof: exact body/import-owner/file-URL comparison for 126 affected TS/MJS modules, all 71 moves accounted for, five static gates, fresh generated documents, 54 new compiled module paths with old paths absent, 517 cases in 48 files, all 518 files discovered once, eight real Linux Inspector filename cases through CLI/MCP, and full installed-package verification (130 tools, six prompts). Actual relocated workflow/reconciliation entrypoints passed; recovery prerequisite imports were also checked from an unrelated working directory. Hosted CI additionally passed real JavaScript recovery using the relocated compiler/default entrypoint, real browser verification, macOS package/Apple artifacts and Windows package/native workflows. Local recording-port tests were not treated as engine proof. The concrete directory/ASAR reader boundary remains intact for a separately traced refactor. Next is a focused native CI increment for Linux arm64/aarch64, Intel macOS and real Inspector coverage across the existing mainstream native hosts; T6 and final extension documentation remain open.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Native baseline CI coverage merged in #898 after all 24 checks passed on the exact submitted head.

  • Installed-package verification passed on Linux x64/arm64 and macOS x64/arm64; the existing Windows x64 native/package lane also passed.
  • Real Node Inspector CLI/MCP verification passed on all five native platform/architecture pairs.
  • Each new matrix entry asserts the actual Node platform and architecture, records Node version, and uses explicit heap/thread/time limits with at most two concurrent jobs per matrix.

This is executed native baseline proof, including Linux aarch64 and Intel macOS, rather than emulated or cross-compiled startup. Real Hopper/Ghidra/IDA/browser/managed-tool conformance remains in its corresponding lane. The testing guide records the ownership and proof boundary. T6 source migrations and final extension documentation continue separately.

<!-- gh-comment-id:6033910100 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Native baseline CI coverage merged in #898 after all 24 checks passed on the exact submitted head. - Installed-package verification passed on Linux x64/arm64 and macOS x64/arm64; the existing Windows x64 native/package lane also passed. - Real Node Inspector CLI/MCP verification passed on all five native platform/architecture pairs. - Each new matrix entry asserts the actual Node platform and architecture, records Node version, and uses explicit heap/thread/time limits with at most two concurrent jobs per matrix. This is executed native baseline proof, including Linux aarch64 and Intel macOS, rather than emulated or cross-compiled startup. Real Hopper/Ghidra/IDA/browser/managed-tool conformance remains in its corresponding lane. The testing guide records the ownership and proof boundary. T6 source migrations and final extension documentation continue separately.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

T6 progress: JavaScript domain and contract ownership

PR #907 groups 116 existing domain files under src/domain/javascript/ and six JavaScript-specific contract/example files under src/contracts/javascript/. Shared Evidence, ordering, comparison semantics and cross-domain workflow contracts retain their existing owners. Source/type/reexport imports, compiled catalog/verifier/SDK paths and recovery CI filters migrated together.

Validation before integration: 251 affected TS/MJS bodies and mapped import/file-URL owners compared exactly; 91 production modules moved in the clean build, old paths disappeared, and all 31 source-only test/fixture exclusions were preserved. Five static gates, generated-document checks, 1183 cases in 88 files, complete test discovery, eight real Linux Inspector fixtures and the installed-package workflow passed. Package startup observed 130 tools/6 prompts on the frozen baseline.

The subsequent main integration preserves the new source-location capability and Android session fixes. Five static gates, fresh build/generated checks and another 153 cases in 11 files passed, including the actual source-location decoder and CLI/MCP. The source-location tool-count increase belongs to upstream, rather than this migration.

Current source investigation identifies the next narrow boundary: JavaScript root/nested ASAR acquisition still owns concrete format handling in application. Extract unchanged file facts and inventory snapshot representation to domain; move acquisition/shared stream hashing to artifacts while preserving the existing ArtifactReader and application try/finally close order. Broader ZIP/native-DMG selection remains a separate lifecycle. T6/T7 closure remains open.

Merged as f6a58f1062 after all 28 checks on e98efe469c completed without failures. Actual hosted native package and Inspector lanes passed on Linux x64/arm64, macOS x64/arm64 and Windows x64, together with real browser/recovery and Apple artifact lanes.

<!-- gh-comment-id:6034872634 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): T6 progress: JavaScript domain and contract ownership PR #907 groups 116 existing domain files under `src/domain/javascript/` and six JavaScript-specific contract/example files under `src/contracts/javascript/`. Shared Evidence, ordering, comparison semantics and cross-domain workflow contracts retain their existing owners. Source/type/reexport imports, compiled catalog/verifier/SDK paths and recovery CI filters migrated together. Validation before integration: 251 affected TS/MJS bodies and mapped import/file-URL owners compared exactly; 91 production modules moved in the clean build, old paths disappeared, and all 31 source-only test/fixture exclusions were preserved. Five static gates, generated-document checks, 1183 cases in 88 files, complete test discovery, eight real Linux Inspector fixtures and the installed-package workflow passed. Package startup observed 130 tools/6 prompts on the frozen baseline. The subsequent main integration preserves the new source-location capability and Android session fixes. Five static gates, fresh build/generated checks and another 153 cases in 11 files passed, including the actual source-location decoder and CLI/MCP. The source-location tool-count increase belongs to upstream, rather than this migration. Current source investigation identifies the next narrow boundary: JavaScript root/nested ASAR acquisition still owns concrete format handling in application. Extract unchanged file facts and inventory snapshot representation to domain; move acquisition/shared stream hashing to artifacts while preserving the existing ArtifactReader and application try/finally close order. Broader ZIP/native-DMG selection remains a separate lifecycle. T6/T7 closure remains open. Merged as f6a58f10629614fb7a6970421218b73d41bce6a5 after all 28 checks on e98efe469ca0b4da3befffcb75febbf01d116e33 completed without failures. Actual hosted native package and Inspector lanes passed on Linux x64/arm64, macOS x64/arm64 and Windows x64, together with real browser/recovery and Apple artifact lanes.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Reader-selection progress in T3/T6/T7: PR #916 gives JavaScript artifact acquisition an adapter owner.

  • Root/nested ASAR handling and relevant-file acquisition now live in src/artifacts/javascript/; the narrow factory returns the existing ArtifactReader. Application retains its original admission/inventory/graph/analysis body and root-reader finally-close sequence.
  • Exact file facts and immutable inventory snapshot moved into domain. Inventory options/integrity policy and the existing application snapshot type reexport remain compatible. Complete-stream hashing and bounded classification evidence moved into artifacts.
  • Guards cover migrated acquisition/hash dependencies and prevent JavaScript workflows from importing concrete ASAR/directory readers. The original source reproduces all three concrete-reader violations. Broader ZIP/native-DMG/Mach-O selection and the older ArtifactProvider workflow facade retain their separately traced boundaries.

Validation: exact declarations/factory/acquisition/hash/lifecycle plus 34 caller bodies/bindings/resolved owners; unchanged generated outputs; five new compiled owners with two obsolete paths absent; all five static gates and fresh docs/build; 377 cases across 37 files with one host-native macOS case skipped on Linux; 529 files discovered once. Actual installed-package CLI/MCP/configuration/Evidence/lifecycle/update passed with 131 tools/six prompts, observed tools/list startup 2108.24 ms and sampled MCP RSS 423223296 bytes. The final report had no owned descendants, and its tarball was cleaned. Heavy local lanes ran serially with two CPUs/one worker/one-GiB heap; no Windows writes.

The next read-only candidate is a coherent managed semantic/workflow/contract owner with its portable conformance verifier, helpers and PE fixture builder. Preserve actual provider parsing and shared target/Evidence owners. Portable fixture conformance, optional actual ILSpy/operator manifests and real Ghidra NativeAOT remain distinct proof levels. T6/T7 final closure remains open.

Merged as f0a68dce60; all 25 checks on abc5e420e8 completed without failures. Actual hosted package and Inspector lanes passed on Linux x64/arm64, macOS x64/arm64 and Windows x64, along with actual Apple artifact and recovery lanes. The merge was already completed by the time this agent issued its merge request.

<!-- gh-comment-id:6035721771 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Reader-selection progress in T3/T6/T7: PR #916 gives JavaScript artifact acquisition an adapter owner. - Root/nested ASAR handling and relevant-file acquisition now live in `src/artifacts/javascript/`; the narrow factory returns the existing ArtifactReader. Application retains its original admission/inventory/graph/analysis body and root-reader finally-close sequence. - Exact file facts and immutable inventory snapshot moved into domain. Inventory options/integrity policy and the existing application snapshot type reexport remain compatible. Complete-stream hashing and bounded classification evidence moved into artifacts. - Guards cover migrated acquisition/hash dependencies and prevent JavaScript workflows from importing concrete ASAR/directory readers. The original source reproduces all three concrete-reader violations. Broader ZIP/native-DMG/Mach-O selection and the older ArtifactProvider workflow facade retain their separately traced boundaries. Validation: exact declarations/factory/acquisition/hash/lifecycle plus 34 caller bodies/bindings/resolved owners; unchanged generated outputs; five new compiled owners with two obsolete paths absent; all five static gates and fresh docs/build; 377 cases across 37 files with one host-native macOS case skipped on Linux; 529 files discovered once. Actual installed-package CLI/MCP/configuration/Evidence/lifecycle/update passed with 131 tools/six prompts, observed tools/list startup 2108.24 ms and sampled MCP RSS 423223296 bytes. The final report had no owned descendants, and its tarball was cleaned. Heavy local lanes ran serially with two CPUs/one worker/one-GiB heap; no Windows writes. The next read-only candidate is a coherent managed semantic/workflow/contract owner with its portable conformance verifier, helpers and PE fixture builder. Preserve actual provider parsing and shared target/Evidence owners. Portable fixture conformance, optional actual ILSpy/operator manifests and real Ghidra NativeAOT remain distinct proof levels. T6/T7 final closure remains open. Merged as f0a68dce60e81b4d2f420bf774b61957a37326ac; all 25 checks on abc5e420e89f47e400206fccf5fd37ac970f1602 completed without failures. Actual hosted package and Inspector lanes passed on Linux x64/arm64, macOS x64/arm64 and Windows x64, along with actual Apple artifact and recovery lanes. The merge was already completed by the time this agent issued its merge request.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Managed capability ownership is now merged in #926 (28713f9b). All 27 checks for its final head passed, including native Linux/macOS x64/arm64 and Windows x64 package/Inspector baselines, browser/recovery, Apple and generated-document lanes.

  • Managed semantics, Evidence workflows and named contracts have their own layer directories. Portable conformance/oracle/manifest helpers and PE fixtures now have coherent script owners. Existing public commands, source implementations, lifecycle and domain-specific contracts are preserved.
  • Exact review covered 70 affected AST bodies and mapped import/file-URL owners. All five static gates, 230 cases in 33 integrated suites and 533-file single-owner discovery passed. Fresh compilation contains all 20 new production owners and none of their old paths; source tests remain excluded.
  • Generated catalog and managed commitments match the integration baseline. Installed CLI/MCP passed with 131 tools and six prompts, no remaining owned descendants and cleaned verifier packaging. Portable fixture checks retain their narrower proof level; unconfigured local ILSpy/operator-manifest inputs remain unsupported.
  • The randomized source-rejection test exposed a separate Babel recovery defect. #929 fixed null call-argument slots with five base-failing regressions, preserving partial coverage and original argument/parameter positions; all 25 checks passed before merge.

Platform baseline consolidation is tracked separately in #935: one macOS version and one package/Inspector baseline per architecture, retaining the distinct Xcode-dependent Apple workflow. The structural roadmap remains active. Next, trace Apple artifact acquisition/native-tool helpers into their producer owner, followed by remaining native/process ownership and concrete extension examples; this increment does not freeze a universal provider contract.

<!-- gh-comment-id:6037093319 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Managed capability ownership is now merged in #926 (28713f9b). All 27 checks for its final head passed, including native Linux/macOS x64/arm64 and Windows x64 package/Inspector baselines, browser/recovery, Apple and generated-document lanes. - Managed semantics, Evidence workflows and named contracts have their own layer directories. Portable conformance/oracle/manifest helpers and PE fixtures now have coherent script owners. Existing public commands, source implementations, lifecycle and domain-specific contracts are preserved. - Exact review covered 70 affected AST bodies and mapped import/file-URL owners. All five static gates, 230 cases in 33 integrated suites and 533-file single-owner discovery passed. Fresh compilation contains all 20 new production owners and none of their old paths; source tests remain excluded. - Generated catalog and managed commitments match the integration baseline. Installed CLI/MCP passed with 131 tools and six prompts, no remaining owned descendants and cleaned verifier packaging. Portable fixture checks retain their narrower proof level; unconfigured local ILSpy/operator-manifest inputs remain unsupported. - The randomized source-rejection test exposed a separate Babel recovery defect. #929 fixed null call-argument slots with five base-failing regressions, preserving partial coverage and original argument/parameter positions; all 25 checks passed before merge. Platform baseline consolidation is tracked separately in #935: one macOS version and one package/Inspector baseline per architecture, retaining the distinct Xcode-dependent Apple workflow. The structural roadmap remains active. Next, trace Apple artifact acquisition/native-tool helpers into their producer owner, followed by remaining native/process ownership and concrete extension examples; this increment does not freeze a universal provider contract.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Apple artifact ownership increment merged in #952 (ef1a0cc6) after all 26 checks passed at final head 16886249.

  • Pure Apple facts now live in domain/apple; the inventory Evidence workflow in application/apple; acquisition, assetutil, plist/NIB and keyed archive producer boundaries in artifacts/apple.
  • Five verifier entrypoints and the bundle fixture builder follow their owners. Public npm commands and named CLI/MCP contracts remain stable. Guards reject outward producer imports.
  • Integrated current bridge-root/framework and chained-fixup fixes with their complete verifier body preserved. Local static/docs/build checks, 247 focused cases, all 539 discovered files, and isolated package CLI/MCP/setup/recovery/lifecycle passed (131 tools, six prompts; no owned descendants left).
  • Real Apple CI passed all five verifiers, 28 native NIB/plist regressions and ten dispatch variants including authenticated arm64e fixups. Both macOS native package/Inspector baselines and Windows passed.

Remaining T6/T7 work includes native/process ownership and the concrete extension map. Next T3 closure removes the application/runtime production-composition exception only after DirectAnalysis, status, MCP and compiled fixture callers migrate; existing BinarySession/factories and cleanup semantics remain authoritative. No universal provider interface or expanded platform support is introduced.

<!-- gh-comment-id:6038639293 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Apple artifact ownership increment merged in #952 (ef1a0cc6) after all 26 checks passed at final head 16886249. - Pure Apple facts now live in domain/apple; the inventory Evidence workflow in application/apple; acquisition, assetutil, plist/NIB and keyed archive producer boundaries in artifacts/apple. - Five verifier entrypoints and the bundle fixture builder follow their owners. Public npm commands and named CLI/MCP contracts remain stable. Guards reject outward producer imports. - Integrated current bridge-root/framework and chained-fixup fixes with their complete verifier body preserved. Local static/docs/build checks, 247 focused cases, all 539 discovered files, and isolated package CLI/MCP/setup/recovery/lifecycle passed (131 tools, six prompts; no owned descendants left). - Real Apple CI passed all five verifiers, 28 native NIB/plist regressions and ten dispatch variants including authenticated arm64e fixups. Both macOS native package/Inspector baselines and Windows passed. Remaining T6/T7 work includes native/process ownership and the concrete extension map. Next T3 closure removes the application/runtime production-composition exception only after DirectAnalysis, status, MCP and compiled fixture callers migrate; existing BinarySession/factories and cleanup semantics remain authoritative. No universal provider interface or expanded platform support is introduced.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Binary production-composition closure merged in #965 after all 22 checks passed at head cdcec115.

  • composition/binary owns the unchanged deep/lazy-auxiliary and managed-only factories. DirectAnalysis/status receive those existing factories explicitly; composition/directAnalysis binds the prior CLI/MCP caller signatures. No session is acquired during binding and independent calls retain independent state.
  • All source/compiled fixture consumers migrated. The former application/runtime file and compiled outputs are removed; the guard now rejects its outward imports and six concrete production providers in application/server.
  • Six factory regressions and seven guard probes passed within 199 focused cases/31 suites; all 540 files discovered once. Static/docs/build, generated commitments and isolated package CLI/MCP/setup/recovery/update/lifecycle passed. Catalog remains 131 tools/six prompts.
  • Real existing Linux Ghidra 12.1.4 CLI and six MCP operations passed, including decompilation, file-byte comparison, preserved caller entries and complete cleanup. Two-CPU supervision observed an owned-family peak RSS of 1090641920 bytes and no surviving owned processes. Both macOS architectures, Linux architectures and Windows CI passed.

Continue T6 with native semantics/workflows, process capture versus Evidence ownership and the remaining artifact inventory/extraction producer boundary. T7 still needs its concrete extension map and final acceptance audit; the roadmap remains open.

<!-- gh-comment-id:6039542153 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Binary production-composition closure merged in #965 after all 22 checks passed at head cdcec115. - composition/binary owns the unchanged deep/lazy-auxiliary and managed-only factories. DirectAnalysis/status receive those existing factories explicitly; composition/directAnalysis binds the prior CLI/MCP caller signatures. No session is acquired during binding and independent calls retain independent state. - All source/compiled fixture consumers migrated. The former application/runtime file and compiled outputs are removed; the guard now rejects its outward imports and six concrete production providers in application/server. - Six factory regressions and seven guard probes passed within 199 focused cases/31 suites; all 540 files discovered once. Static/docs/build, generated commitments and isolated package CLI/MCP/setup/recovery/update/lifecycle passed. Catalog remains 131 tools/six prompts. - Real existing Linux Ghidra 12.1.4 CLI and six MCP operations passed, including decompilation, file-byte comparison, preserved caller entries and complete cleanup. Two-CPU supervision observed an owned-family peak RSS of 1090641920 bytes and no surviving owned processes. Both macOS architectures, Linux architectures and Windows CI passed. Continue T6 with native semantics/workflows, process capture versus Evidence ownership and the remaining artifact inventory/extraction producer boundary. T7 still needs its concrete extension map and final acceptance audit; the roadmap remains open.
bsakaguchi commented 2026-10-15 18:23:59 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Native analyst source ownership merged in #973 after all 24 checks passed at head 4649625c.

  • 25 existing files now have domain/native (15), application/native (9), and contracts/native (1) owners. Actual native/provider protocols, shared dossier/aggregates and host-verifier locations stay at their existing owners.
  • All 66 affected TS/MJS implementations/assertions/import targets/file URLs match the baseline after path mapping. Eighteen compiled owners replace the old outputs, seven source test outputs excluded; generated catalog/conformance commitments remain byte-identical. All 554 tests discovered once.
  • 274 local focused cases and static/docs/build checks passed. Isolated package CLI/MCP/setup/recovery/update/lifecycle passed with the baseline 133 tools/six prompts and no owned descendants.
  • Existing real Linux Ghidra CLI/six MCP operations passed with a byte oracle and complete runtime/caller-entry cleanup. Two-CPU family peak RSS 1064628224 bytes.
  • Real Apple CI passed all existing workflows and three newly selected Swift-demangling CLI/MCP cases, completing all local host skips. Both macOS package/Inspector baselines, Linux architectures, Windows, source/coverage and actual JavaScript recovery passed.

Next T6 increment separates process capture/PTY implementation from analyst Evidence/comparison workflows and follows all installed capability-probe paths. Remaining artifact producer ownership, host/verifier moves and the T7 extension map remain tracked here; no universal contract or expanded platform claim is introduced.

<!-- gh-comment-id:6040384735 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Native analyst source ownership merged in #973 after all 24 checks passed at head 4649625c. - 25 existing files now have domain/native (15), application/native (9), and contracts/native (1) owners. Actual native/provider protocols, shared dossier/aggregates and host-verifier locations stay at their existing owners. - All 66 affected TS/MJS implementations/assertions/import targets/file URLs match the baseline after path mapping. Eighteen compiled owners replace the old outputs, seven source test outputs excluded; generated catalog/conformance commitments remain byte-identical. All 554 tests discovered once. - 274 local focused cases and static/docs/build checks passed. Isolated package CLI/MCP/setup/recovery/update/lifecycle passed with the baseline 133 tools/six prompts and no owned descendants. - Existing real Linux Ghidra CLI/six MCP operations passed with a byte oracle and complete runtime/caller-entry cleanup. Two-CPU family peak RSS 1064628224 bytes. - Real Apple CI passed all existing workflows and three newly selected Swift-demangling CLI/MCP cases, completing all local host skips. Both macOS package/Inspector baselines, Linux architectures, Windows, source/coverage and actual JavaScript recovery passed. Next T6 increment separates process capture/PTY implementation from analyst Evidence/comparison workflows and follows all installed capability-probe paths. Remaining artifact producer ownership, host/verifier moves and the T7 extension map remain tracked here; no universal contract or expanded platform claim is introduced.
bsakaguchi commented 2026-10-15 18:24:00 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 7, 2026):

Artifact inventory/extraction ownership migration is merged in #1032 (6e4535c1).

  • Format classification, policy, reader selection, canonical inventory scanning and graph construction now belong to src/artifacts/inventory/.
  • Transactional extraction belongs to src/artifacts/extraction/; default caller destination selection belongs to src/application/artifacts/.
  • Existing snapshot semantics stay in the domain owner. Acquisition guards now cover inventory and extraction, with resolved dependency regressions for application/composition/CLI/MCP boundaries.
  • Producer bodies, import identities and file-URL roots were compared against the frozen base; public CLI/MCP contracts and Evidence semantics are preserved. Installed-package MCP verification now checks extraction bytes, inline Evidence and output cleanup.

Verification: 33 focused files (275 passing tests, three host-specific skips); all 535 test files discovered exactly once; strict typecheck, module boundaries, lint, formatting, Knip and generated-document checks passed. An isolated actual npm consumer verified ZIP/ASAR CLI and MCP inventory/extraction, JavaScript application analysis, complete inventory parity, unchanged source bytes and cleanup. The complete package gate also passed locally.

All 23 final-head checks passed, including real Apple artifact CLI/MCP and Linux x64/arm64, macOS x64/arm64 and Windows package lanes: CI run.

Ownership and extension guidance is maintained in docs/capability-migration.md. Keep the remaining domain/verification migrations and final cross-domain contract closure on this roadmap; shared interfaces should follow the concrete migrated boundaries.

<!-- gh-comment-id:6047583723 --> @N0zoM1z0 commented on GitHub (Oct 7, 2026): Artifact inventory/extraction ownership migration is merged in #1032 (`6e4535c1`). - Format classification, policy, reader selection, canonical inventory scanning and graph construction now belong to `src/artifacts/inventory/`. - Transactional extraction belongs to `src/artifacts/extraction/`; default caller destination selection belongs to `src/application/artifacts/`. - Existing snapshot semantics stay in the domain owner. Acquisition guards now cover inventory and extraction, with resolved dependency regressions for application/composition/CLI/MCP boundaries. - Producer bodies, import identities and file-URL roots were compared against the frozen base; public CLI/MCP contracts and Evidence semantics are preserved. Installed-package MCP verification now checks extraction bytes, inline Evidence and output cleanup. Verification: 33 focused files (275 passing tests, three host-specific skips); all 535 test files discovered exactly once; strict typecheck, module boundaries, lint, formatting, Knip and generated-document checks passed. An isolated actual npm consumer verified ZIP/ASAR CLI and MCP inventory/extraction, JavaScript application analysis, complete inventory parity, unchanged source bytes and cleanup. The complete package gate also passed locally. All 23 final-head checks passed, including real Apple artifact CLI/MCP and Linux x64/arm64, macOS x64/arm64 and Windows package lanes: [CI run](https://github.com/morluto/rea/actions/runs/37691178106). Ownership and extension guidance is maintained in `docs/capability-migration.md`. Keep the remaining domain/verification migrations and final cross-domain contract closure on this roadmap; shared interfaces should follow the concrete migrated boundaries.
bsakaguchi commented 2026-10-15 18:24:00 +00:00
Author
Owner
Copy link

@N0zoM1z0 commented on GitHub (Oct 11, 2026):

Merged #1713 as d9b4ae182d60dfd7fd5ba5bb539716413cbfdca6. Native command failures now preserve the typed process supervisor through both command capture and xcrun resolution. The launching runner retains every incomplete owner, retries cleanup before later commands, and preserves all failure resources/reasons. Native clients and Mach-O readers join their own launched commands before the close retry; failed cleanup remains retryable, and the shared runner is still available to other clients. Named failure options avoid expanding the positional constructor. Reader cleanup also uses an explicit failure observation instead of an ambiguous undefined sentinel.

42 focused tests passed locally and again on the fresh merged build. Coverage includes actual Linux child commands, partial output, cancellation, signal termination and capacity controls, plus injected production-boundary incomplete cleanup, multiple retained owners, blocked relaunch, recovery and concurrent close. An owner-transfer-only mutation reproduced the missing-owner assertion before source restoration. This does not claim a real kernel cleanup failure or local real macOS Xcode verification.

All 31 exact-head CI checks passed. The actual merged tree and reviewed source blobs matched; the fresh merged build also passed complete CLI/SDK-MCP results, IDs, text/structured parity, unchanged target bytes, ping and package-session close on small ZIP/JavaScript targets. The combined readiness full-report oracle remained unchanged. Owned build/generator outputs and unnecessary intermediates were cleaned; compact reproduction evidence and receipts remain in /tmp.

<!-- gh-comment-id:6105927671 --> @N0zoM1z0 commented on GitHub (Oct 11, 2026): <!-- rea-native-command-1713-merged --> Merged [#1713](https://github.com/morluto/rea/pull/1713) as `d9b4ae182d60dfd7fd5ba5bb539716413cbfdca6`. Native command failures now preserve the typed process supervisor through both command capture and xcrun resolution. The launching runner retains every incomplete owner, retries cleanup before later commands, and preserves all failure resources/reasons. Native clients and Mach-O readers join their own launched commands before the close retry; failed cleanup remains retryable, and the shared runner is still available to other clients. Named failure options avoid expanding the positional constructor. Reader cleanup also uses an explicit failure observation instead of an ambiguous undefined sentinel. 42 focused tests passed locally and again on the fresh merged build. Coverage includes actual Linux child commands, partial output, cancellation, signal termination and capacity controls, plus injected production-boundary incomplete cleanup, multiple retained owners, blocked relaunch, recovery and concurrent close. An owner-transfer-only mutation reproduced the missing-owner assertion before source restoration. This does not claim a real kernel cleanup failure or local real macOS Xcode verification. All 31 exact-head CI checks passed. The actual merged tree and reviewed source blobs matched; the fresh merged build also passed complete CLI/SDK-MCP results, IDs, text/structured parity, unchanged target bytes, ping and package-session close on small ZIP/JavaScript targets. The combined readiness full-report oracle remained unchanged. Owned build/generator outputs and unnecessary intermediates were cleaned; compact reproduction evidence and receipts remain in `/tmp`.
Sign in to join this conversation.
No Branch/Tag specified
Branches Tags
main
codex/procedure-reference-stacked
release-please--branches--main--components--rea-agents
release-please--branches--main--components--rea-agents--release-notes
codex/kuna-independent-retry
codex/byte-search-overlay-coverage
codex/open-failure-target-receipt
codex/kuna-xref-evidence
codex/ghidra-ambiguous-procedure-recovery
codex/function-source-bundle
codex/trace-function-integration-prototype
codex/snapshot-source-closure
codex/recorded-evidence-array-pages
codex/evidence-recovery-redesign
codex/trace-feature-address-scope
codex/call-discovery-scope
codex/ghidra-literal-candidate-evidence
codex/decompile-directory-independent-retry
codex/retry-provenance-base
codex/value-flow-capability-experiment
codex/ghidra-containing-instruction
cursor/readme-discord-button-ef9f
dependabot/github_actions/actions/setup-node-7.1.0
dependabot/github_actions/actions/upload-artifact-7.0.2
dependabot/npm_and_yarn/npm-minor-and-patch-d8d97ce6df
codex/kuna-1989
fix/8559-native-ui-fixture-ownership
fix/8555-go-verifier-mcp-ownership
codex/provider-capability-recovery
fix/8642-rizin-target-stdin
codex/ghidra-memory-effect-scope
codex/ghidra-annotation-entry-selector
codex/ghidra-readonly-recovery
codex/ghidra-regex-verifier-recovery
codex/evidence-discovery-view-guidance
fix/8545-bulk-append-overflow
fix/8428-navigation-refusal-alternatives
codex/address-context-recovery
codex/matching-member-limitations
codex/unknown-scope-contract
codex/evidence-view-guidance
feat/8373-native-trace-views
codex/ghidra-snapshot-verifier-binding
codex/elf-export-visibility
codex/evidence-view-recovery
codex/native-reference-cli-help
codex/provider-candidate-observation-scope
codex/kuna-session-verification
codex/ghidra-switch-lifetime-guidance
codex/pseudocode-paging-discovery
codex/clarify-evidence-view-support
codex/kuna-xrefs-selector-recovery
codex/context-capacity-recovery
codex/evidence-closure-large-links
codex/same-function-evidence-identity
codex/ghidra-verifier-inspected-jdk
codex/audit-guided-workflows
codex/crash-prompt-retained-dossiers
codex/analysis-view-error-recovery
codex/kuna-verifier-target-selection
codex/ghidra-selected-project-call-coverage
codex/docs-native-analysis-scope
codex/ghidra-java-socket-boundary
codex/ghidra-retained-snapshot-verifier
codex/ghidra-search-inventory-facts
fix/8284-zero-argument-parameter-bindings
fix/8198-ui-action-handler-offset
fix/8257-elf-entry-label-identity
fix/8304-deferred-output-schema-projection
fix/8277-call-path-computed-target-uncertainty
fix/pr-8089-conflicts
fix/ci-static-duplicate-export
dependabot/npm_and_yarn/lint-staged-17.6.0
dependabot/github_actions/actions/download-artifact-8.0.2
dependabot/npm_and_yarn/write-file-atomic-8.0.0
dependabot/npm_and_yarn/canonicalize-5.1.0
dependabot/github_actions/actions/cache/restore-6.1.0
dependabot/npm_and_yarn/toon-format/toon-4.4.0
dependabot/github_actions/actions/deploy-pages-5.0.1
codex/review-fixes-pr-2403
codex/review-fixes-pr-2400
codex/process-terminal-width
codex/test-brittleness-cleanup
verify/7167-browser-connect-macos
fix/7167-browser-connect
feat/native-matching-allowance-setting
feat/browser-scenario-dry-run
test/managed-caller-parameters-20261024
codex/parser-fortythird-boundaries
fix/6926-pinvoke-platform-decorations-20261023
fix/6889-har-body-encoding-20261023
fix/6888-sqlite-schema-budget-20261023
fix/dependency-security-gates-6708
cursor/evidence-overwrite-rebase-b4ac
feat/4057-verify-native-exports
fix/windows-acl-observer-overhead-20261022
cursor/erlang-beam-restack-4476
cursor/pe-certificate-review-bf32
fix/6116-javascript-application-fs-errors
fix/6061-unmapped-runtime-script-unknown
feat/browser-scenario-summary
fix/pe-certificates
codex/verify-3407
cursor/rebase-5699
cursor/rebase-5352
cursor/rebase-5600
cursor/fix-cli-schema-omission-10a8
codex/audit-hopper-shutdown-reasons-20261021
fix/demangle-swift-omitted-record
fix/nib-boolean-value-types
cursor/cancellation-partial-observation-a5ac
fix/ib-object-limit-reasons
fix/electron-fuse-limit-advice
fix/kuna-doctor-dangling-cache
fix/fixed-budget-refusal-advice
fix/js-ipc-listener-dedup
fix/js-return-member-provenance
fix/dmg-integrity-retry-advice
fix/ida-doctor-readiness
fix/kuna-version-probe-output-drain
fix/legacy-swift-runtime-name-matching
fix/dylib-lazy-load-commands
fix/browser-scenario-startup-cancel
fix/swift-nested-punycode-classification
fix/compare-unselected-scopes
fix/objc-method-budget-coverage
fix/dmg-mounted-root-observations
audit/ci-tests-20261019-round2
release/6.7.0
fix/wabt-cleanup-retry-resolution
fix/electron-fuse-elf-pe-architecture
fix/native-plist-descriptor-ownership
fix/kuna-caller-cleanup-ownership
experiment/atomic-codemode-20261016
review/first-contributor-3776
fix/call-resolution-full-read-cycles
fix/member-mutation-selection-repeat
experiment/atomic-re-tools-20261015
perf/member-mutation-lazy-origins
perf/static-network-mutation-index
fix/hopper-startup-lifecycle
audit/3050-windows-proof-20261015
feat/windows-window-capture-2183
audit/3049-windows-proof-20261015
audit/3735-macos-fixtures-20261015
fix/batch-decompile-null-pseudocode
fix/kuna-inventory-honors-jobs
experiment/browser-codemode-tool-design-20261015
fix/hopper-clean-runtime-argv
codex/review-2049-27f1b367
review-fixes/pr-2787-routing
fix/3360-scoped-this-emitters
fix/3367-replaced-global-effects
fix/3838-compact-any-value-items
test/hopper-download-probe-20261015
codex/windows-runtime-creation-red-green-20261015
codex/windows-readonly-root-red-green-20261015
codex/windows-root-share-red-green-20261015
codex/exp-1685-win-mcp-startup
codex/bug-sweep-20261015
investigate/2190-windows-package-phases
investigate/3543-macos-cli-deadline
perf/3281-reverse-tools-feedback-quality
fix/3406-hopper-doctor-fixture
fix/3341-wrapper-require-test-context
fix/3301-owned-uninstall-fixtures
fix/3164-compiler-input-ownership
fix/pcap-cleanup-stdout-newline-20261014
perf/interface-builder-summary
codex/review-fixes-pr-1977
fix/ghidra-effective-jvm-platform
fix/docs-turkish-rust-link-20261013
fix/main-maintenance-ci-20261010
fix/recover-binary-session-process-effects
codex/review-fixes-pr-2457
codex/ci-required-cancellation-gate
fix/main-format-baseline-20261013
fix/setup-preserve-entry-fields
cursor/restore-main-checks-1ffc
fix/ghidra-bridge-hashmap-import
codex/shared-ci-jadx-json-default-20261013
codex/shared-ci-ghidra-test-groups-20261013
codex/shared-ci-java-fixture-format-20261013
codex/fix-intrinsic-invocation-boundaries
test/release-preflight-reusable-jobs
test/js-parameter-provenance-expectation
fix/linux-hopper-verification-current
test/2419-ghidra-elf-probe-size
followup/pr-1544-native-ida
codex/fold-pr-2230-contribution
docs/readme-responsible-use
fix/issue-2064
fix/issue-2050
fix/issue-2053
fix/issue-1968
fix/issue-1945
experiment/codemode-bridge-20261011
fix/tool-effects-negative-wording-1904-20261012
fix/1842-electron-interop-provenance
feat/recover-javascript-multi-input
refactor/website-i18n-prep
fix/nativeaot-pe-virtual-extent
fix/browser-verifier-ci-hang
fix/pe-resources-input-selection
docs/beginner-friendly-guides
docs/beginner-setup-guide
fix/javascript-analysis-worker-1563
fix/1649-ghidra-duplicate-names
fix/javascript-export-keys-integration-1369
test/maintenance-boundary-contracts-20261011
review/javascript-export-keys-1369
review/process-live-progress-1483
test/javascript-1495-growth-ratio
fix/ci-escape-timing
docs/normalized-terminal-geometry-1450
release/6.3.0
archive/release-6.3.0-pr1381
release/6.2.0
fix/electron-preload-dynamic-override
fix/javascript-self-referential-bundler-edges
release/6.1.0
cursor/grok-client-cherry-pick-0b56
feat/signature-posture
feat/dyld-shared-cache
feat/artifact-integrity-policy
feat/pkg-inventory
release/6.0.0
chore/sync-release-5.0.0
release/5.0.0
cursor/cloud-agent-node-787e
fix/javascript-xhr-open-endpoints
review/pr-711-realpath-fallback-wording
cleanup/replay-confinement
codex/test-suite-performance
codex/issue-foundations
codex/address-open-issues-2026-07-20
agent/javascript-vite-rollup-esbuild-adapters
agent/process-cleanup
agent/triage-integration
agent/unknown-commands-registry
feat/mcp-identity-metadata
morlvps/issue_cleanup
codex/installer-redesign
morl/roadmap-investigation-core
morl/roadmap-investigation-docs
release-please--branches--main--components--rea
rea-agents-6.8.0
rea-agents-6.7.0
rea-agents-6.6.0
experiment/atomic-codemode-wait-runtime-20261016
rea-agents-6.5.0
rea-agents-6.4.0
rea-agents-6.3.0
rea-agents-6.2.0
rea-agents-6.1.0
rea-agents-6.0.0
rea-agents-5.0.0
rea-agents-4.1.0
rea-agents-4.0.1
rea-agents-4.0.0
rea-agents-3.2.1
rea-agents-3.2.0
rea-agents-3.1.0
rea-agents-3.0.0
rea-agents-2.7.0
rea-agents-2.6.0
rea-agents-2.5.1
rea-agents-2.5.0
rea-agents-2.4.0
rea-agents-2.3.0
rea-agents-2.2.0
rea-agents-2.1.0
rea-agents-2.0.0
rea-agents-1.7.0
rea-agents-1.6.0
rea-agents-1.5.0
rea-agents-1.4.0
rea-agents-1.3.0
rea-agents-1.2.0
rea-agents-1.1.0
rea-agents-1.0.0
rea-agents-0.5.0
rea-agents-0.4.0
rea-agents-0.3.0
rea-0.2.1
rea-0.2.0
Labels
Clear labels   
area: bridge

   
area: bridge

   
area: build

   
area: build

   
area: build

   
area: cli

   
area: domain

   
area: evidence

   
area: mcp

   
area: native

   
area: providers

   
area: runtime

   
area: server

   
area: setup

   
area: tests

   
bug

   
design

   
documentation

   
enhancement

   
enhancement

   
enhancement

   
experiment

   
help wanted

   
i18n

   
invalid

   
P0: critical

   
P1: high

   
P2: medium

   
P2: medium

   
P2: medium

   
P3: low

   
performance

   
provider-request

   
pull-request
Mirrored from GitHub Pull Request

  
question

   
roadmap

   
triage
No labels
area: bridge
area: bridge
area: build
area: build
area: build
area: cli
area: domain
area: evidence
area: mcp
area: native
area: providers
area: runtime
area: server
area: setup
area: tests
bug
design
documentation
enhancement
enhancement
enhancement
experiment
help wanted
i18n
invalid
P0: critical
P1: high
P2: medium
P2: medium
P2: medium
P3: low
performance
provider-request
pull-request
question
roadmap
triage
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
morluto/rea#329
No description provided.