npm - gcad-agents - Versions diffs - 0.1.0 → 0.1.1 - Mend

gcad-agents 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/generatedPackageMetadata.js +1 -1
package/package.json +1 -1
package/skills/gcad/SKILL.md +0 -108
package/skills/gcad/references/android-applications.md +0 -34
package/skills/gcad/references/connection-and-recovery.md +0 -127
package/skills/gcad/references/dual-path-re.md +0 -97
package/skills/gcad/references/ecu-a2l.md +0 -42
package/skills/gcad/references/evidence-workflows.md +0 -71
package/skills/gcad/references/investigation-workflow.md +0 -79
package/skills/gcad/references/javascript-applications.md +0 -175
package/skills/gcad/references/native-and-artifacts.md +0 -269
package/skills/gcad/references/parity-loop.md +0 -42
package/skills/gcad/references/rewrite-language.md +0 -27
package/skills/gcad/references/runtime-observation.md +0 -78

package/dist/generatedPackageMetadata.js CHANGED Viewed

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "gcad-agents",
-    version: "0.1.0", // x-release-please-version
+    version: "0.1.1", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "gcad-agents",
   "mcpName": "io.github.gcad/gcad",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "GCAD: REA-superset MCP for reverse engineering plus clean-room parity reconstruction loops.",
   "license": "MIT",
   "repository": {

package/skills/gcad/SKILL.md DELETED Viewed

@@ -1,108 +0,0 @@
----
-name: gcad
-description: Reverse engineer artifacts with REA-class tools, then run GCAD clean-room parity reconstruction loops (observe||re → sanitize → implement → judge). Use for shipped binaries, runtime evidence, and parity-app shipping gates.
-metadata:
-  version: "1"
-  tool_count: "241"
----
-# GCAD
-Use GCAD when a claim depends on a shipped binary or package, decompilation,
-passive runtime evidence, comparison with behavior not established by available
-source, **or** a clean-room parity reconstruction (ledger, sanitize wall, Phase
-gates).
-For ordinary analysis of a complete source repository without RE or parity
-goals, use normal repository tools.
-## Connect (skill ≠ MCP)
-Installing this skill supplies instructions only. It does not register the GCAD
-MCP server, install analysis engines, or add tools to a running agent.
-If REA/GCAD tools are available, go to the target. Do not run diagnostics before
-every task. Use the connected server's tool list and schemas. Keep complete
-inline Evidence when the server does not advertise retained references.
-If tools are absent, a call is blocked, or a required provider is unavailable,
-read [connection and recovery](references/connection-and-recovery.md). Diagnose
-the observed blocker. Continue useful supported work. Resume after repair.
-## Route by input
-Choose the first tool from the **artifact** the user supplied. GCAD is dual-path:
-**PC** (modern apps) and **MCU/ECU** (ROM + calibration), one MCP.
-Use `open_binary` for active-target native or archive work. Target-free tools
-take their own path or endpoint.
-| Artifact / hint | First tool | Lane |
-|---|---|---|
-| `.a2l` (+ optional ROM) | `inspect_a2l` | ECU |
-| Raw dump + arch (TriCore/ARM/RH850/ppc-raw) | `open_binary` `format=raw-binary` | ECU |
-| Two ROM/tune dumps, same map | `compare_raw_images` | Shared → ECU |
-| Native PE/DLL (Windows) | `open_binary`; optional `inspect_pe_layout` | PC |
-| Managed PE | `inspect_managed_artifact` | PC |
-| JS/Electron tree | `analyze_javascript_application` | PC |
-| Linux firmware FS image | `inspect_firmware_regions` | Shared |
-| Parity workspace | `parity_workspace_bind` | Parity |
-**Fail closed:** raw / `.bin` / `.hex` / `.s19` without architecture — ask once
-for arch + base/map **or** A2L. Do not guess TriCore vs ARM. Offline
-caller-owned dumps only — no live XCP/UDS write, seed-key, or unauthorized flash.
-If the user says only "my app" without a name, path, or selected target, ask
-which app before searching. Do not pick an example app for the user.
-Full route map (PC, ECU, archives, captures, WASM, EVM, Go/Rust, SQLite, IDA):
-[dual-path RE](references/dual-path-re.md).
-ECU/A2L detail: [ecu-a2l](references/ecu-a2l.md).
-## Parity reconstruction
-When reconstructing a vendor app, read [parity loop](references/parity-loop.md).
-Call `parity_workspace_bind` first. Prefer in-process REA tools for the RE lane,
-then `parity_re_ingest` and `parity_sanitize_slice`. Role `clean` must never
-read `dirty/**`. Guided prompts: `gcad_dirty_observe`, `gcad_dirty_re`,
-`gcad_sanitize`, `gcad_choose_rewrite_language`, `gcad_clean_impl`, `gcad_judge`.
-**Rewrite language:** After the first RE overview, call
-`recommend_rewrite_languages`, **ask the human**, then
-`parity_rewrite_language_set` (or `other` + label). Do not start clean impl
-until a choice is stored. Detail: [rewrite-language.md](references/rewrite-language.md).
-## Work summary-first
-Start with the default result and its inline Evidence. For large JS or ELF
-layout work, use `"detail": "summary"`, then `inspect_analysis_view` on the
-retained `parent_evidence_id`. Do not repeat an identical analysis without a
-changed input or resolved blocker.
-Distinguish observations, inferences, and unknowns. Cite Evidence IDs. Preserve
-limitations. Static analysis does not observe execution.
-Staged multi-feature investigations:
-[investigation workflow](references/investigation-workflow.md).
-Evidence paging, comparisons, unknowns:
-[evidence workflows](references/evidence-workflows.md).
-## Read the relevant guide
-- Dual-path routing (PC vs MCU/ECU): [dual-path-re.md](references/dual-path-re.md)
-- ECU / A2L / raw ROM: [ecu-a2l.md](references/ecu-a2l.md)
-- Parity loop: [parity-loop.md](references/parity-loop.md)
-- Rewrite language choice: [rewrite-language.md](references/rewrite-language.md)
-- Native, managed, archives: [native-and-artifacts.md](references/native-and-artifacts.md)
-- JavaScript / Electron / ASAR: [javascript-applications.md](references/javascript-applications.md)
-- Android APK: [android-applications.md](references/android-applications.md)
-- Browser / Electron runtime: [runtime-observation.md](references/runtime-observation.md)
-- Evidence / compare / verify: [evidence-workflows.md](references/evidence-workflows.md)
-- Connection / recovery: [connection-and-recovery.md](references/connection-and-recovery.md)
-- Investigation staging: [investigation-workflow.md](references/investigation-workflow.md)
-## Finish
-Explain findings in plain language and tie them to returned evidence. When the
-user asks to build something, use normal coding tools and separate observed
-behavior from design choices. Close an opened native session with `close_binary`
-when the investigation is complete.

package/skills/gcad/references/android-applications.md DELETED Viewed

@@ -1,34 +0,0 @@
-# Android application artifacts
-Use the connected server's advertised Android tools. Repository main and npm
-4.1.0 include this family. A skill installation alone cannot add it to an
-older server.
-Start with `inspect_android_package` on the caller's APK path for package
-identity, manifest declarations, coverage, and inline Evidence. Use
-`search_android_classes` to find candidates, `inspect_android_class` for one
-class's members, `inspect_android_method` for decompilation, and
-`trace_android_references` for incoming static references. Each call takes its
-own APK path and explicit selectors; do not open a native session first.
-Choose an `overload_index` from the class inventory when methods are ambiguous
-instead of guessing.
-The provider requires a separately supplied headless JADX MCP JAR 0.7.1 and
-Java 17 or newer. `REA_JADX_MCP_JAR` selects the absolute JAR path; `JAVA_HOME`
-can select Java. REA setup does not install or configure that JAR, and doctor
-provider scopes cover Hopper/Ghidra rather than JADX. Use existing tools and
-report missing prerequisites for the Android task specifically.
-Linux and macOS use the POSIX owned-process boundary. Windows x64 requires the
-matching bundled native controls and uses an owned Job Object with bidirectional
-stdio. A full JDK, including `jdk.compiler`, is required on every host; Windows
-`JAVA_HOME` selects `bin\java.exe`. Consult the Android guide for actual host
-verification coverage. Calls use one worker and provider deadlines; optional
-`REA_JADX_HEAP_MIB` selects the JVM heap. The APK is never launched,
-and no emulator is required.
-Manifest entries and decompiled text are static observations, not execution or
-policy enforcement. Incoming references are recovered static relationships;
-reflection, dynamic loading, and unresolved calls remain unknown. Preserve
-artifact digests, locations, diagnostics, and incomplete coverage. For archive
-members rather than code analysis, use `open_binary` and `inspect_artifact`.

package/skills/gcad/references/connection-and-recovery.md DELETED Viewed

@@ -1,127 +0,0 @@
-# Connection and task recovery
-Read this guide only for an observed connection, command, approval or provider
-blocker. Keep the user's target and question in view. Explain what prevented the
-operation and the next useful step; after repair, continue the investigation.
-Commands below use an installed `rea`. If none is available, use the package
-invocation in `SKILL.md` when acquiring REA is authorized. Follow the connected
-server's schemas and the installed CLI's help rather than assuming repository
-main and an older release expose the same arguments.
-## Choose the remedy from the observed failure
-| Observation                                                     | Meaning and next step                                                                                                                                                                                                                                                                                                 |
-| --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| No REA tools in the active session                              | Inspect registration with `rea doctor --client codex --json`. A skill installation alone does not register MCP.                                                                                                                                                                                                       |
-| Missing, malformed or stale registration                        | Prepare a scoped setup plan; apply only authorized changes with backups.                                                                                                                                                                                                                                              |
-| Aligned registration, but no connected tools                    | Restart/reconnect the client. Doctor checks registration; it cannot establish the current agent's connection. Inspect the client's launch error if reconnection fails.                                                                                                                                                |
-| `MCP tool call requires approval, but approval policy is never` | Codex rejected the call before REA executed it. Do not install an engine or repeat setup to solve this client-policy decision. See the approval section below.                                                                                                                                                        |
-| REA returns `provider_unavailable` or an unavailable tool entry | Read that operation's provider diagnostics or `binary_session.result.tool_availability`. Expand each group's tool names and inherit the shared client requirements unless overridden. Use the operation's availability, reason, and remediation; a complete tool catalog does not imply every operation is available. |
-| `rea` is missing in a child shell, or Node is incompatible      | Inspect the actual shell PATH and launcher/runtime. A prefix installation may be absent from a login shell's PATH; this does not establish a broken MCP registration.                                                                                                                                                 |
-If the client cannot launch its shell/sandbox helper or read the installed skill,
-inspect its launch diagnostic. For example, Codex can refuse helper aliases when
-CODEX_HOME is under `/tmp`; use an authorized profile outside the OS temporary
-directory. REA setup cannot repair the client's executor. Preserve the sandbox
-instead of silently disabling it to make an analysis command work.
-Static JavaScript and ordinary ZIP inventory need neither Hopper nor Ghidra.
-HAR inspection is offline and does not require a live browser. Native
-decompilation, Android analysis and firmware extraction have their own
-bring-your-own prerequisites. Use supported inventory/static evidence when it
-answers part of the question, and name the unavailable evidence separately.
-Do not substitute another target. Label observations from ordinary shell tools
-as such; only actual REA output supplies REA Evidence.
-## Repair registration when needed
-For Codex:
-```bash
-rea doctor --client codex --json
-rea setup --client codex --dry-run --json
-```
-Use the current supported client's ID: `claude_code`, `claude_desktop`, `codex`,
-`cursor`, `gemini_cli`, `windsurf`, `devin`, `opencode`, `antigravity`,
-`copilot_cli`, `commandcode`, `qwen_code`, `vscode`, `trae`, `grok_build`, `omp`, `pi`,
-`hermes`, `qoder`, `droid`, `zcode`, `dsh`, or `grok_bot`. If unknown, inspect `doctor --json` before choosing a
-scope. `grok_bot` uses a chat registration step rather than local `mcp.json`.
-For unsupported clients, use version-pinned manual stdio registration or CLI.
-Show the plan's exact paths, backups, changes and bundled-skill replacement.
-Obtain approval for writes when that concrete scope is not already authorized,
-then apply the same scope with `rea setup --client codex --yes`. Add
-`--install-hopper` only when separately needed and explicitly approved. Do not
-install or upgrade unrelated prerequisites. Restart/reconnect, verify tools
-actually appear, and resume the original task. If they remain absent, inspect
-the launch failure rather than looping through setup.
-## Codex tool approval is separate from REA readiness
-REA tools have no permission-grant handshake. Codex can still require approval
-because an operation creates owned resources, launches a helper or has cleanup
-effects. An advertised tool or successful doctor result does not override that
-client policy. `workspace-write` alone does not resolve an MCP approval
-rejection, and `approval_policy = "never"` does not mean every MCP tool is
-preapproved.
-When interactive approval is available, use the client's approval flow for the
-requested operation. In an unattended run, continue through an authorized CLI
-workflow if the execution environment permits it, or report the blocked
-operation and the approval needed to proceed. Do not retry the same rejected
-call, silently broaden approvals, or rewrite MCP effects as read-only.
-For an operator who explicitly wants to preapprove named operations in a
-disposable Codex profile, current Codex supports per-tool configuration. For
-example, opening and closing an analysis session can be scoped independently:
-```toml
-[mcp_servers.rea.tools.open_binary]
-approval_mode = "approve"
-[mcp_servers.rea.tools.close_binary]
-approval_mode = "approve"
-```
-Use the actual server ID and only the operations whose effects were approved;
-this example does not approve inspection, extraction or runtime execution.
-Show the proposed config edit and preserve unrelated entries and backups before
-writing. Managed policy can constrain client settings. Consult the
-[Codex configuration reference](https://learn.chatgpt.com/docs/config-file/config-reference)
-for the installed client's supported settings. This is an optional recovery
-choice, not a prerequisite for every REA task.
-## Continue through an installed CLI
-Check the command environment only if the launcher fails:
-```bash
-command -v rea
-command -v node
-node --version
-rea --version
-```
-Use the public launcher at its known installation path with a supported existing
-Node on PATH when the child shell loses a prefix installation. Avoid internal
-`dist/cli.js` entrypoints or global toolchain changes. MCP may have its own valid
-launcher even when a shell cannot resolve `rea`.
-For a user-supplied JavaScript tree or ASAR, select output files in the authorized
-workspace and save complete Evidence before reading a view:
-```bash
-rea analyze-javascript-application /absolute/path/to/app --json > app-evidence.json
-jq -c '{source: {kind: "inline", evidence: .}, view: {kind: "summary"}}' app-evidence.json > app-view.json
-rea inspect-analysis-view app-view.json
-```
-These commands do not register MCP or install an analysis engine. CLI JavaScript
-JSON is complete and can be very large; redirect it rather than loading it into
-context. Use an existing JSON processor if `jq` is absent, without installing
-one just for this recipe. Inspect a module page or item using the same inline
-source and the [JavaScript recipes](javascript-applications.md). Preserve graph
-coverage, limitations and unknowns. Native CLI analysis still requires its
-selected engine, and all CLI operations retain the host's execution permissions.

package/skills/gcad/references/dual-path-re.md DELETED Viewed

@@ -1,97 +0,0 @@
-# Dual-path RE routing
-Choose the first tool from the artifact. **PC** and **MCU/ECU** share one MCP.
-Use `open_binary` for active-target native or archive work. Target-free tools
-take their own explicit path or endpoint.
-## Quick table
-| Artifact / hint | First tool | Lane |
-|---|---|---|
-| `.a2l` (+ optional ROM) | `inspect_a2l` | ECU |
-| Raw dump + `architecture=tricore` (+ map) | `open_binary` `format=raw-binary` | ECU |
-| Raw dump + ARM/Cortex-M / RH850 / ppc-raw | `open_binary` raw profile | ECU |
-| Two ROM/tune dumps, same map | `compare_raw_images` | Shared → ECU |
-| Native PE/DLL on Windows | `open_binary` (Ghidra); optional `inspect_pe_layout` | PC |
-| Managed PE | `inspect_managed_artifact` | PC |
-| JS/Electron tree | `analyze_javascript_application` | PC |
-| Linux firmware FS image | `inspect_firmware_regions` | Shared (Linux BYO) |
-| Parity workspace | `parity_workspace_bind` | Parity |
-**Fail closed:** raw/`.bin`/`.hex`/`.s19` without architecture — ask once for
-arch + base/map **or** A2L. Do not guess TriCore vs ARM. Do not use Binwalk as a
-substitute for an ECU load map. Offline caller-owned dumps only — no live
-XCP/UDS write, seed-key, or unauthorized flash.
-ECU detail: [ecu-a2l.md](ecu-a2l.md).
-## PC and shared first tools
-- ASAP2/A2L: `inspect_a2l` first; then optional raw `open_binary` with
-  `memory_map` / addresses from A2L. See [ecu-a2l.md](ecu-a2l.md).
-- MCU/ECU headerless dump (`format=raw-binary` or `.bin`/`.hex`/`.s19` with
-  caller `architecture`, optional `memory_map`, optional `language_id`):
-  `open_binary`. TriCore flash often maps near `0x80000000`.
-- Calibration heuristics (no A2L): `discover_calibration_candidates` —
-  candidates only, never oracle truth.
-- ASAR or extracted JavaScript/Electron tree:
-  `analyze_javascript_application`. See [javascript-applications.md](javascript-applications.md).
-- Archive/package member inventory (ZIP/APK/IPA/MSIX/AppX or DMG):
-  `open_binary` with the local path; use `inspect_artifact` when its graph helps.
-- Android APK code/classes/methods: `inspect_android_package`, then focused
-  Android tools. See [android-applications.md](android-applications.md).
-- Managed PE/CLI: `inspect_managed_artifact`.
-- Consumer firmware FS carve (not ECU cal): `inspect_firmware_regions` when
-  advertised on Linux BYO. Use `extract_firmware` with a caller-selected new
-  absolute output directory when extraction is requested.
-- .NET NativeAOT PE/ELF: native Ghidra via `open_binary`. Optional metadata
-  recovery: [native-and-artifacts.md](native-and-artifacts.md).
-- User-owned browser page already open: `list_browser_targets`.
-- Browser actions the agent must perform: `capture_browser_scenario` with
-  declared actions. See [runtime-observation.md](runtime-observation.md).
-- Fiddler Everywhere / SAZ: [runtime-observation.md](runtime-observation.md#fiddler-everywhere-traffic-debugging).
-  Saved SAZ: `inspect_web_network_capture` with `format: "saz"`.
-- Retained HAR/SAZ/mitmproxy/aioquic qlog: `inspect_web_network_capture`.
-  Prefer detail summary, then kind pages. Do not fetch recorded URLs.
-- User-owned Electron runtime: `list_electron_targets`. Check
-  `inspect_electron_fuses` before electron-main Inspector; disabled
-  `EnableNodeCliInspectArguments` means the app ignores `--inspect`.
-- Packet-field discovery: `inspect_packet_fields` before
-  `inspect_packet_capture` (Linux + `REA_TSHARK_COMMAND`; recordings only).
-- Address/DNS/SNI summaries: `inspect_pcap_capture` (Wireshark 4.x tshark).
-- Signal decoder discovery: `inspect_signal_decoders`; recordings:
-  `decode_signal_recording` (Linux + `REA_SIGROK_COMMAND`).
-- Local WebAssembly: `inspect_wasm_artifact` (`REA_WABT_BIN_DIRECTORY`).
-- Local EVM bytecode: `inspect_evm_interface` with `raw` or `hex` encoding.
-  Prefer `detail: "summary"`; page via `parent_evidence_id`.
-- Go build metadata: `inspect_go_binary` (target-free; no Go install).
-- Rust cargo-auditable: `inspect_rust_binary` (target-free; no Rust install).
-- SQLite snapshot: `inspect_sqlite_database` (Node 24.15+/26+). Schema first.
-- Linux ELF offline layout: `inspect_binary_layout` (pwntools; no DB).
-- Linux x86-64 ELF core: `inspect_recorded_crash`.
-- PE resources: `inspect_pe_resources`. PE layout: `inspect_pe_layout`.
-- Native executable/library/DB: `open_binary`, then focused tools;
-  `binary_overview` when inventory helps.
-Depth for native/managed/archives: [native-and-artifacts.md](native-and-artifacts.md).
-## IDA
-For an existing IDA MCP configuration, use `open_binary` with the original
-input binary and `provider_id: "ida"`. Do not pass an `.idb` or `.i64`.
-Proceed to `analyze_function`, pseudocode, or searches after opening. IDA does
-not supply `binary_overview`.
-## Target identity and session
-If the user says only "my app" without a name, path, or selected target, ask
-which app before searching. Paths in unrelated reports and nearby fixtures do
-not select the target. Resolve a human-readable name to one clear installed
-artifact when possible; ask when matches are ambiguous.
-In a target-free session, use `open_binary` to bind archive/package or native
-targets whose tools need an active target. Do not call an unadvertised tool.
-Inspect `binary_session` with `{}` and `result.tool_availability` for reasons
-and remediation. The grouped name union is the complete inventory; use
-`tools/list` for schemas. Provider candidates and top-level session
-capabilities are different scopes — do not treat them as interchangeable.

package/skills/gcad/references/ecu-a2l.md DELETED Viewed

@@ -1,42 +0,0 @@
-# ECU / A2L / raw ROM
-Offline **caller-owned** dumps and description files only. No live XCP/UDS
-write, seed-key, or unauthorized flash.
-## Fail closed
-Raw / `.bin` / `.hex` / `.s19` without architecture: ask once for arch +
-base/map **or** an A2L. Do not guess TriCore vs ARM. Do not use Binwalk as a
-substitute for an ECU load map.
-## A2L first
-1. `inspect_a2l` on the ASAP2/A2L description.
-2. Optional: `open_binary` on the ROM/dump with `format=raw-binary`,
-   `architecture`, and `memory_map` / addresses from the A2L when present.
-## Raw dump without A2L
-Call `open_binary` with:
-- `format=raw-binary` (or path ending `.bin` / `.hex` / `.s19`)
-- caller `architecture` (e.g. `tricore`, ARM/Cortex-M, RH850, ppc-raw)
-- optional `memory_map`, optional `language_id`
-TriCore flash often maps near `0x80000000`.
-## Calibration heuristics
-`discover_calibration_candidates` returns **candidates only**. Never treat
-them as oracle truth. Prefer A2L-backed addresses when available.
-## Compare tunes
-Two ROM/tune dumps that share a map: `compare_raw_images`.
-## Not ECU
-Linux firmware filesystem carve uses `inspect_firmware_regions` /
-`extract_firmware` (Linux BYO). That path is consumer firmware FS, not ECU
-calibration. See [dual-path-re.md](dual-path-re.md) and
-[native-and-artifacts.md](native-and-artifacts.md).

package/skills/gcad/references/evidence-workflows.md DELETED Viewed

@@ -1,71 +0,0 @@
-# Evidence, comparison, and verification workflows
-Evidence-producing tools return the complete Evidence record directly in MCP
-`structuredContent` and CLI JSON. Read `normalized_result` for operation data,
-and cite `evidence_id` when another tool or your explanation needs a stable
-reference. Preserve authority, limitations, coverage, and residual unknowns. If a result
-is incomplete or paginated, continue only when the remaining data matters to
-the task; do not fetch a bundle or resource merely to read a result already
-returned inline. When complete `inspect_binary_layout` or
-`analyze_javascript_application` Evidence is already retained, call
-`inspect_analysis_view` for a summary, one section/symbol/module, or a stable
-page instead of repeating the producer.
-Completed `inspect_artifact` inventory also supports a summary and
-`view: {kind: "inventory", collection: "occurrences", logical_paths: ["package.json", "main.js"]}`.
-Omit `logical_paths` to page all available occurrences; `[]` selects none.
-Other inventory collections are `nodes`, `edges` and
-`integrity_contradictions`. Keep `source_complete` separate from page exhaustion:
-a missing match in partial source Evidence does not establish absence. Use the
-returned parent Evidence ID for subsequent views and export before closing the
-session when the source must survive it.
-When `tools/list` advertises `inspect_artifact.detail`, request `"summary"` to
-retain its complete source and receive that view immediately. Without that
-advertised choice, keep the existing complete call. CLI inspection returns
-portable complete Evidence; save it before projecting a selected inline view.
-Use `record_unknown` to track unresolved questions in the user's investigation
-and name the authority or environment still required. Supply supporting and
-contradicting evidence IDs. It updates the session registry directly.
-Use `update_unknown` with the current revision; reread after a stale revision
-instead of retrying blindly. Only qualifying observed evidence can verify a
-resolution.
-Use comparisons with complete, compatible page sets when claiming equivalence
-or absence:
-- `compare_artifacts` compares inventory pages by occurrence path, content,
-  metadata, and graph relations.
-- `compare_functions` compares explicit function Evidence, not fuzzy
-  whole-binary matches.
-- `compare_bundles` compares canonical bundle membership and unknown history.
-- `find_changed_behavior` combines existing comparisons; static differences
-  remain candidates, not causal proof.
-- `build_call_path` needs explicit function dossiers from one artifact/provider;
-  an incomplete frontier makes absence unknown.
-- `correlate_static_and_runtime` uses explicit mappings; matching patterns are
-  hypotheses, not causality.
-- `verify_reconstruction` evaluates a finite typed specification. A pass covers
-  only declared comparable claims, not global equivalence.
-Process captures are opt-in behavioral evidence, not a security sandbox. V3
-captures cannot be upgraded to V4; rerun the original scenario. Distinguish root
-exit from descendant settlement and require freshness when the task needs it.
-A timed-out target that must write a final report needs `finalization_ms`: REA
-sends SIGTERM to the captured root, keeps observing, and sends SIGKILL once
-only if the target has not exited by the end of the interval.
-`exit.finalization.signals` lists each attempt with its delivery result; the
-observed exit signal stays in `exit.signal`, `exit.code` is null for every
-deadline exit, and the code of a finalizer that exited on its own is in
-`exit.finalization.exit_code` (null on a signal exit or when no exit was
-observed).
-Use `inspect_analysis_view` with `view: {kind: "api-surface"}` on retained
-`inspect_web_network_capture` HAR Evidence to group observed request lines by
-method, origin and path template. Format matches are inferences, not handler
-identity or schemas. Group pages cite parent record ordinals; consult record
-coverage and exclusions before claiming completeness. No requests are replayed.
-When the connected schema advertises `include_query_parameter_names`, select
-it in the view for distinct observed names with original record ordinals. Query
-values are omitted; the names establish neither required parameters nor a
-complete server schema. Keep the original parent Evidence for exact URLs.

package/skills/gcad/references/investigation-workflow.md DELETED Viewed

@@ -1,79 +0,0 @@
-# Investigation workflow
-## Work summary-first
-Start with the default result and its inline Evidence and graph context.
-For a JavaScript application or ELF layout whose size is unknown or large,
-call `analyze_javascript_application` or `inspect_binary_layout` with
-`"detail": "summary"`, then inspect the retained `parent_evidence_id` with
-`inspect_analysis_view`. Page module identities and select the returned
-`node_id` before requesting an item. A single file path can represent several
-graph roles.
-Do not repeat an identical analysis or rejected call without a changed input
-or resolved blocker. Recheck session state when a lifecycle change makes that
-status useful. Make a focused follow-up only when the returned result leaves a
-specific question unanswered.
-If MCP reports `resource_constraint` with `details.resource: "transport"`,
-call `inspect_analysis_view` with the same-session Evidence reference for a
-summary, one section/module, or a stable page. Use `trace_application_feature`
-once a seed is known, or `export_evidence_bundle` to write the complete
-session to a selected path. Avoid repeating analysis only to request the same
-oversized response.
-When the retained parent ID is unknown, use `get_evidence_bundle` with
-`detail: "summary"` and exact filters (operation, target SHA-256,
-analysis-profile digest, or canonical procedure address). Select its returned
-Evidence ID for the next view.
-A client can truncate a successful tool result without a REA transport error.
-Treat that preview as incomplete. Use the retained parent ID for smaller views
-or export. Do not parse the preview as canonical JSON or repeat the producer.
-For JavaScript, read [javascript-applications.md](javascript-applications.md)
-before drilling into a large graph.
-Every conclusion must distinguish observations, inferences, and unknowns. Cite
-Evidence IDs. Preserve limitations and incomplete coverage. Never imply that
-static analysis observed execution. Runtime requests execute only the declared
-target and lifecycle.
-Within the user's requested investigation, call available analysis tools
-directly. REA does not require permission grants or per-call approval flags.
-The agent client can still require approval. Use
-[connection-and-recovery.md](connection-and-recovery.md) for an observed
-client-policy rejection.
-Evidence paging, comparisons, unknowns:
-[evidence-workflows.md](evidence-workflows.md).
-## Plan broader investigations
-For requests that span multiple features or subsystems:
-1. Turn the request into a checklist of questions and the evidence each answer
-   needs. Resolve target identity from the conversation and workspace before
-   asking again.
-2. Inspect the current session, artifact identity, saved analysis database,
-   bookmarks, and prior evidence. Reuse matching state; do not open duplicate
-   sessions or repeat identical analysis.
-3. Start with the smallest useful overview or inventory. Follow each question
-   from its entry point through relevant data and state changes. Batch related
-   operations around a specific hypothesis. Expand only when evidence leaves a
-   concrete gap.
-4. Inspect packaged resources and configuration alongside code when they affect
-   the question. Use format-aware inventory and parsers. Do not infer behavior
-   from filenames, strings, or layout alone.
-5. Corroborate with the evidence type the conclusion requires. Use runtime
-   observation only when static evidence cannot answer and the required host
-   runtime is available.
-6. Decompose into independent questions. When parallel workers are available
-   and questions do not depend on one another, assign distinct scopes and ask
-   for sources, conclusions, and unresolved gaps. Otherwise work sequentially.
-7. Keep a concise finding ledger linking each conclusion to Evidence IDs,
-   confidence/evidence type, search boundary, and remaining unknowns.
-Before finishing, revisit the checklist. Mark each question answered, partially
-answered, or unresolved. Keep bounded negative searches bounded. Do not
-describe a broad investigation as complete while required questions remain open.

package/skills/gcad/references/javascript-applications.md DELETED Viewed

@@ -1,175 +0,0 @@
-# JavaScript and Electron application artifacts
-For captured or bundled JavaScript that needs readable source recovery, use
-`recover_javascript_sources` with an absolute `path` and absent
-`output_directory`. Supply related runtime/shared/lazy files in
-`additional_paths` when advertised, then analyze the returned `analysis_input`
-directory together. Each input retains its own snapshot, digest and byte-range
-provenance; inputs and recovered code are never executed. Recovery requires a
-caller-supplied Wakaru on Linux x64; see [the recovery guide](https://github.com/morluto/rea/blob/main/docs/javascript-recovery.md).
-Use `analyze_javascript_application` directly on the operator-supplied ASAR or
-extracted tree. When the question concerns known source paths and the connected
-schema advertises `source_paths`, select exact inventoried paths such as
-`["package.json", "main.js", "preload.js"]`. Include supporting manifests or
-source maps explicitly; dependencies are not implicitly analyzed. REA retains
-the complete artifact inventory and identity but reads source text and analyzes
-only selected files. The result and summary record `source_selection`; files
-outside scope and their relationships remain unknown, so partial application
-coverage does not mean the selected source failed. Use repeated `--source-path`
-on either static application CLI route. Omit the selection when the question
-requires complete application analysis. `detail: "summary"` reduces delivery
-and does not by itself reduce analysis work.
-Exact `#alias` specifiers resolve through the importer's
-enclosing package `imports` map to package-local files; nested `node_modules`
-packages use their own map. Wildcard, recursive, and external-package import
-targets stay unresolved with that limitation. When size is unknown or large and the connected schema advertises
-`detail`, request `detail: "summary"`. This returns an `inspect_analysis_view`
-Evidence record with a distinct ID and a `normalized_result.parent_evidence_id`
-for the complete retained application analysis. Source-map contents are part of
-that static analysis. Read findings, coverage, limitations and unknowns, then
-follow a specific unanswered question. Older servers without `detail` return
-the complete application Evidence inline when it fits.
-When the connected schema advertises `max_heap_mb` and `analysis_timeout_ms`,
-these select the isolated source analyzer's old-space heap and per-source
-deadline. Defaults are 1024 MiB and 300000 ms. They do not change the MCP
-process heap. A Bun-hosted REA does not enforce the heap choice; on Windows it
-instead limits the analyzer's committed memory to that choice plus a 512 MiB
-runtime reserve.
-Resource-limited analyses preserve completed static facts and
-report partial semantic coverage with specific unknown scopes; this does not
-mean the source is malformed. Inspect those limits before retrying a source.
-When expanded relationships exceed the parent's available memory, inspect the
-file's modules item view for retained `static_analysis` and
-`semantic_module_analysis`. Their facts remain available even when graph links
-are unknown. Cumulative result exhaustion can stop analysis before every file
-is examined; the inventory and remaining unknown scopes distinguish that case.
-Timeout or cancellation after source analysis begins retains partial Evidence
-in the same session. A returned `error.details.partial_observation` reference
-can be supplied directly to `inspect_analysis_view`. If the SDK cancels locally, retrieve its recorded ID from
-the Evidence bundle before inspecting the partial analysis.
-## Read a module without repeating analysis
-Use the actual returned parent ID, on the same connection, as `source.evidence_id`.
-The following IDs are placeholders to replace with returned values. When the
-module's node ID is not already known, page identities before selecting an item.
-Pages return only node IDs, paths and roles; choose a useful page size and follow
-`coverage.next_offset` when another page matters:
-```json
-{
-  "source": {
-    "kind": "retained-evidence",
-    "evidence_id": "ev_ACTUAL_PARENT_ID"
-  },
-  "view": { "kind": "page", "collection": "modules", "offset": 0, "limit": 16 }
-}
-```
-Select the relevant page entry by its exact `node_id` and recorded role:
-```json
-{
-  "source": {
-    "kind": "retained-evidence",
-    "evidence_id": "ev_ACTUAL_PARENT_ID"
-  },
-  "view": {
-    "kind": "item",
-    "collection": "modules",
-    "selector": { "node_id": "jag_node_ACTUAL_NODE_ID" }
-  }
-}
-```
-Module pages include asset, bundled and source module roles, so one path can
-identify several entries. Use `selector.path` only when uniqueness is established;
-the returned node ID avoids needing a complete inventory to prove uniqueness. On ambiguity,
-select the matching node ID from the page or the error's candidates. Follow
-`next_offset` when another page matters. An item exposes that module node's
-recorded observations, identity, hashes, exports and source ranges; it does not
-include every child syntax observation, related edge or original source file.
-An absent item fact is not evidence of absence from the whole application.
-## Trace only the remaining question
-Use `trace_application_feature` on the parent application Evidence for one
-literal node ID, route, string, API, IPC channel, module, or native export.
-Select `incoming` for relationships leading to the seed, `outgoing` for those
-leaving it, and `both` when the question needs both. Trace traversal includes
-containment relationships, so even a narrow seed can expand many nodes; a
-bidirectional trace can reach unrelated sibling modules. A module item or page
-is preferable when its observations already answer the question. Do not treat
-all reached nodes as participants in the feature.
-Reuse retained parent Evidence when the server advertises it, or supply complete
-Evidence inline. Include Hopper or Ghidra Evidence only when its artifact digest
-matches exactly.
-## Recover an oversized display
-An oversized response reports `resource_constraint` and
-`details.resource: "transport"`. Reuse
-`details.reported_limits.evidence_reference` with `inspect_analysis_view` for a
-summary, one module, or a stable page of module identities.
-`export_evidence_bundle` writes the complete canonical session to a
-caller-selected file. These workflows keep the original Evidence and coverage;
-a broad follow-up can also exceed framing.
-A client can truncate a successful result inside its text envelope without a
-REA `resource_constraint`. Treat a truncation notice or incomplete JSON as a
-display limitation; do not claim the full record was examined. Reuse the known
-parent ID for smaller views, or export complete Evidence to a selected file
-while the session remains open. If the parent ID was lost from the preview,
-use the prior analysis summary or explicit ledger entries to recover it; do
-not invent an ID or rerun analysis just to reproduce the same display.
-BrowserWindow preferences, preload and contextBridge surfaces, IPC
-registrations, utility processes, and native binding requests are static syntax
-observations. Only a unique exact literal IPC channel match supports an inferred
-pairing. Dynamic or ambiguous channels remain unresolved. A requested `.node`
-member is not a verified native export. Never claim runtime reachability,
-registration, defaults, or policy enforcement from static analysis.
-For version comparison, analyze each version once, then call
-`compare_application_versions`. Accept only its digest, source-map, structural
-fingerprint, or non-module semantic matches. Module ordinals and minified names
-are not persistent identity. Report added or removed only with complete
-opposite-side coverage; otherwise report unknown.
-When the question asks how one exact exported callable's returned object shape
-changed, analyze each version once and then call
-`compare_javascript_export_shapes` with explicit module paths and export names.
-Use the returned IDs on the same connection, or complete inline Evidence
-records, from both analysis calls. Accept variant
-pairing only through the tool's unique exact literal discriminant. Read
-`property_inventories` and each change's `presence` before treating `unknown` as
-"the name was not observed": inventories list observed property names even when
-values stay unknown, with a `source_range` for each paired or unpaired variant.
-Array holes and mutation-invalidated slots are not observed properties.
-Complete parent coverage reports presence-only
-`added`/`removed` independently of unresolved values. Cite the
-comparison Evidence and report JSON Pointer changes; dynamic values, ambiguous
-variants, and incomplete parent-property coverage stay unknown. This is static
-inference, not runtime behavior. When runtime semantics are needed, run
-behavioral probes against the relevant application versions and capture them
-through the available browser, Electron, or process workflows.
-## Reusing application Evidence
-When advertised by the connected server, application trace and compare tools
-accept complete inline Evidence or
-`{"kind":"retained-evidence","evidence_id":"ev_<64 lowercase hex characters>"}`
-for their application input (`application`, or `left`/`right`). `inspect_analysis_view`
-uses the same retained-reference form in `source`, or portable inline Evidence,
-to project a summary, module page, or one module with its recorded observations. This notation is
-a template: replace it with the actual returned ID. Versions before 4.1.0 accept only full
-inline Evidence. Use the exact ID
-returned by the producer on the same MCP connection. Resolution does not run
-analysis or select a provider; findings remain inline. Native observation
-arrays still take full Evidence. `close_binary` clears retained references;
-export a bundle before closing, or supply portable inline Evidence in another
-connection. A missing reference includes its ID and recovery guidance.

package/skills/gcad/references/native-and-artifacts.md DELETED Viewed

@@ -1,269 +0,0 @@
-# Native, managed, and packaged artifacts
-## Go build metadata
-Use `inspect_go_binary` for an explicit local ELF, PE or thin Mach-O when the
-question concerns the embedded compiler version, module/dependency versions,
-local replacements or build settings. No `open_binary`, Go installation or
-target execution is required. The CLI equivalent is `inspect-go-binary PATH`.
-Preserve artifact SHA-256, original file ranges, framed module bytes and every
-unparsed module-text line. A missing record is an unknown, not proof of a
-non-Go binary; observed metadata does not authenticate its claims. Function,
-source and type recovery remain a separate native-analysis question.
-## Rust dependency metadata
-Use `inspect_rust_binary` for an explicit local ELF, PE, or thin Mach-O when
-the question concerns the cargo-auditable crate list embedded in `.dep-v0`
-(Mach-O: `__DATA,.dep-v0`). No `open_binary`, Rust installation, or target
-execution is required. The CLI equivalent is `inspect-rust-binary PATH`.
-Preserve artifact SHA-256, package order, dependency indices, and the section
-file range. A missing section is null metadata, not proof the binary has no
-dependencies. An omitted package kind stays null. A rustc commit hash is
-inferred from a read-only `/rustc/<40-hex>/` path and does not by itself
-identify the compiler. See [Rust binaries](https://github.com/morluto/rea/blob/main/docs/rust-binaries.md).
-## SQLite snapshots
-Use `inspect_sqlite_database` with an explicit local database snapshot for its
-schema and optional rows from one exact ordinary table. It requires Node.js
-24.x >=24.15 or 26+ with the native `DatabaseSync.limits` API. It also consumes the
-existing sibling `-wal`; retain both original digests when citing its result.
-Default output is a compact inventory; a selected table expands only its own
-schema and samples 20 rows. Select `columns` to avoid irrelevant or large cells,
-and request `schema_scope: "database"` only for complete schema details.
-Choose `row_limit` when a finite sample is useful and keep truncation and
-unspecified row order explicit. Virtual tables, shadow tables and views are
-schema facts, not row-read targets. REA inspects private copies and leaves
-the source files untouched; obtain a coherent quiescent database/WAL snapshot
-before inspection. See [SQLite snapshots](https://github.com/morluto/rea/blob/main/docs/sqlite-databases.md).
-## Recorded Linux crashes
-Use `inspect_recorded_crash` with an explicit Linux x86-64 ELF core path to
-inspect historical thread registers, signals, raw notes and original file
-ranges. It is independent of the active disassembler target. Source-bound
-register values and note bytes are observations; missing notes, signal-thread
-association and current executable/library identity remain unknown. PIDs are
-historical metadata and never authorize live attach or control.
-The optional `include_debugger_context` facet adds mapping candidates through
-caller-supplied GDB/pwndbg in an owned core-only session. Display names do not
-establish current file identity; zero reported flags leave permissions unknown.
-Requested unavailable context fails with setup guidance. See
-[recorded crashes](https://github.com/morluto/rea/blob/main/docs/recorded-crashes.md)
-for exact upstream profiles, bounds and verification coverage.
-## Offline ELF layout
-Use `inspect_binary_layout` with an explicit local ELF path for file-backed
-sections, symbols, relocations, linkage names, and static mitigation inferences
-without opening a disassembler target. When that complete record is already
-retained, call `inspect_analysis_view` for a summary, mitigations or linkage
-facet, one section or symbol, or a stable page. Do not re-run the decoder to
-read a single object.
-## Offline WASM
-Use `inspect_wasm_artifact` with caller-supplied WABT for selected local bytes.
-For counts, validation and WAT identity, select `detail: "summary"` on the first
-MCP call. The complete original Evidence stays retained; use
-`normalized_result.parent_evidence_id` for exact exports or text pages. Omitted
-or complete detail keeps the existing complete result.
-For a completed result, use `inspect_analysis_view` with its reported retained
-reference for a summary or `view: {kind: "wasm", facet: "exports", offset: 0, limit: 32}`.
-Facets also include sections, imports, candidates, glue, WAT, headers, details
-and tool profile. Text offsets count UTF-16 code units; follow `next_offset`.
-The complete source remains retained after an oversized MCP reply. No target
-execution or network acquisition is implied, and WAT is decoded representation.
-## Native targets
-After `open_binary`, use focused search, procedure, or function tools directly.
-Use `binary_overview` when target metadata or inventory context helps answer the
-question. Prefer literal search, names, decompilation, callers, callees, and
-cross-references. Addresses and recovered pseudocode are analysis observations,
-not original source. Provider unavailability and unsupported metadata remain
-unknown rather than false.
-For a completed `analyze_function` dossier, use `inspect_analysis_view` with
-`view: {kind: "native", facet: "value_flow_operations", offset: 0, limit: 32}`
-and the exact retained Evidence ID to read selected facts without reanalysis.
-Native facets also include procedure, pseudocode, assembly, basic blocks,
-comments, callers/callees, references, unresolved calls, referenced strings and
-names, the native API record, and value-flow summaries. Pseudocode offsets and limits count UTF-16
-code units; use the returned `next_offset` for continuation. Provider limitations
-and unavailable facts remain explicit; the complete parent Evidence is retained.
-`inspect_macho` on a large framework returns megabytes of imports and exports.
-Select `detail: "summary"` for slice identity, UUID and per-collection counts,
-then page rows with `view: {kind: "macho", facet: "exports", offset: 0, limit: 64}`
-and `normalized_result.parent_evidence_id`. Facets are entrypoints,
-architectures, build_metadata, load_commands, dependencies, imports, exports,
-segments and provenance. `source_exhaustive: false` means unreturned symbols
-may exist.
-To see which functions or Objective-C methods a Mach-O actually calls in one
-run, use `observe_native_calls` with explicit breakpoints and a bounded
-`duration_ms`/`max_events`. It launches a new process under LLDB, so the target
-runs and may change files or use the network. Hardened-runtime targets need the
-`get-task-allow` entitlement.
-Use `binary_session` with no arguments to check the open target, selected
-provider, and alignment. Its default `result.tool_availability` carries a
-complete inventory grouped by shared facts. Expand each group's `names` and
-inherit the inventory-level client requirements unless a group overrides them;
-availability, reasons, remediation, modes, and flags remain inline. The
-`effects` and `annotations` arrays name true flags from fixed vocabularies, so an
-omitted known flag is false. `tools/list` remains the canonical source for full
-tool schemas when target or provider state changes.
-Provider capability groups carry provider identity and ordered limitations.
-Prepend each set's `shared_limitations` to a group's `limitations` to recover the
-operation's full ordered list. Candidate capabilities describe possible
-providers. Top-level session capabilities describe the current route, and
-`analysis_provider_binding` identifies the selected provider.
-## DOS MZ with Ghidra
-For an admitted DOS MZ target, use `inspect_native_load_image` to check measured
-loaded bytes, file mappings, relocations and the entry against the immutable
-snapshot. Keep `mismatch` and `unsupported` explicit. Verified import covers the
-reported static image, not runtime DOS or PC-98 hardware behavior.
-For Ghidra decompilation, `procedure_pseudo_code` also accepts `procedure: "file-offset:0x..."`; CLI `rea decompile <path> --file-offset=0x... --provider ghidra` resolves the source byte offset internally. An unresolved 0x-prefixed numeric procedure selector also falls back to a unique file mapping. Existing symbols and analysis addresses win; multiple mappings fail as ambiguous. Preserve the returned file-offset and address locations and raw selection observations. ELF virtual addresses are distinct from file offsets; never assume an arbitrary offset plus image base is an analysis address.
-Use `read_bytes` for initialized analysis memory and `address_to_file_offset` to
-anchor one observed address to original file bytes. Loader fixups can change a
-word; a source offset does not imply byte equality. Complete function body ranges
-use inclusive ends and can contain gaps. Do not treat the enclosing span as code.
-For packed targets, retain the original and separately derived artifact identities;
-decompiling an unpacking stub does not recover the unpacked program.
-When reading Objective-C dispatch metadata, distinguish class implementation
-methods from protocol requirements: class methods report null requirement
-flags, while decoded protocol declarations retain required and optional facts.
-Property attributes remain raw name/value tokens; use the property's
-`atomicity` field for the decoded `N` marker or the default atomic behavior.
-Null class/meta flags, ivar counts, atomicity, or read-only values mean the
-selected provider did not establish that fact. Symbol names alone do not prove
-that a class is a root class or has no ivars.
-## Managed PE/CLI
-Start with `inspect_managed_artifact`. REA's canonical managed inspection is
-execution-free: do not claim it loaded, reflected, executed, or resolved the
-assembly. Keep managed/native boundaries and unavailable reconstruction facts
-explicit. A bring-your-own reconstruction oracle is separate from the canonical
-parser and must not become an implicit setup dependency.
-For identity/classification questions, `inspect_managed_artifact` can explicitly
-select `detail: "summary"` on the first MCP call. It retains complete metadata
-and returns a linked overview with full classification/evidence, nullable
-module/MVID, frameworks, metadata coverage/issues/limitations and returned-row
-counts. Default complete requests remain unchanged. Read original rows with
-`inspect_analysis_view`, source `normalized_result.parent_evidence_id`, and
-`view: {kind: "managed", collection: "attributes", offset: 0, limit: 16}`.
-Collections are `references`, `resources` and `attributes`. Paging does not
-repeat parsing. Returned-row exhaustion
-does not prove complete metadata or absence under partial/unavailable coverage;
-preserve build-local tokens and their artifact/MVID scope.
-### .NET NativeAOT
-NativeAOT binaries contain native machine code, so ordinary CIL decompilers
-cannot recover the original method bodies. When managed metadata/CIL is absent,
-classify that as a native-analysis route rather than claiming source recovery.
-Open the native image with the selected deep provider and inspect functions,
-strings, calls, and references; describe decompiler output as pseudocode and
-inference.
-NativeAOT images can be PE/COFF, ELF, or Mach-O executables and shared
-libraries. Use file bytes and loader metadata rather than suffixes to identify
-them. For packaged apps, inventory/extract with REA's artifact tools and retain
-the exact contained image identity. PDB, ELF debug, or dSYM sidecars are
-additional evidence only when the provider accepts and matches them.
-REA has a built-in read-only snapshot parser for x64 PE targets with .NET 8 RTR
-9.1 metadata. An optional headless Ghidra adapter adds database annotations and
-broader metadata recovery on Linux; it requires an explicitly configured
-NativeAOT JAR. These are separate routes. The built-in parser also runs on
-Windows Ghidra P0; read frozen literals from its report, because
-`search_strings` does not include them. See the
-[NativeAOT guide](https://github.com/morluto/rea/blob/main/docs/ghidra-nativeaot.md)
-for setup, supported layouts, and host restrictions. Preserve binary identity
-and distinguish derived metadata from Ghidra database observations. Recovered
-types and native pseudocode are not original C# source. Windows Ghidra P0 has
-no database mutation authority.
-## Packages and extraction
-Use `inspect_artifact` for application bundles, archives, ZIP/APK/IPA/MSIX/AppX,
-ASAR, or DMG inputs when the artifact graph and findings help answer the
-question. It returns the complete artifact graph inline. Cite graph manifest
-IDs when using them.
-For an IPA or a macOS `.app`, ZIP, or DMG, pass the inventory Evidence to
-`project_apple_application_graph`. It reports application roots and nested
-bundles by path convention: app extensions, XPC services, frameworks, login
-items, system and driver extensions, and plug-ins. It also lists privileged
-helpers, launchd plists, symlinks, and each bundle's `info_plist_path` and
-executable candidates. Roles are path conventions, not parsed plists; read the
-listed plists with `inspect_plist`.
-After `open_binary` on a `.app` or Mach-O, use `trace_dylib_resolution` to see
-which file each `@rpath`, `@loader_path` and `@executable_path` load reaches for
-every executable in the bundle. It also lists missing or weak loads and earlier
-`@rpath` candidates that are absent. Narrow large bundles with `roots` or
-`architecture`. System paths stay undetermined because the dyld shared cache
-provides them.
-Use `extract_artifact` when materialized files are needed. It extracts the active
-target and accepts optional `integrity_policy`; see the [MCP contracts](https://github.com/morluto/rea/blob/main/docs/mcp-contracts.md).
-It materializes all regular files into a fresh temporary directory chosen by
-REA. Symlinks and encrypted entries are inventory facts, not extractable files.
-The result reports the materialized directory; callers do not choose the
-destination. No separate permission grant is needed.
-Native DMG traversal automatically uses a read-only mount on supported macOS
-hosts, with an owned temporary mount directory and cleanup. It needs no approval
-flag. Unsupported hosts or mount failures remain explicit limitations; do not
-claim child inventory when only root identity is available. Extraction is a
-separate filesystem-writing operation.
-For headerless DOS COM, explicitly open with `format: "dos-com"` (CLI
-`--target-format dos-com`). Inspect the load image before trusting function
-analysis: the entry is `0x10100`, file offset zero, with imposed real-mode segment
-context. PSP/stack/device state remains unmodeled. See [DOS guide](https://github.com/morluto/rea/blob/main/docs/ghidra-dos.md).
-For other headerless images (embedded firmware without ELF/Mach-O/PE/MZ
-headers), open with `format: "raw-binary"`, `architecture` (`x86`, `x86_64`,
-`arm`, `arm64`, or `6502`), and `entry_point` (`0x` hex). File offset 0 is mapped at
-that address. Hopper and IDA refuse this interpretation; Ghidra uses
-`BinaryLoader` with a little-endian generic language. Big-endian, Thumb-only,
-and Cortex-M variants are unsupported. `6502` selects NMOS 6502; the entry and
-complete file mapping must fit within `0x0000..0xffff`. 65C02, 65816, cartridge
-containers, bank switching, and mapper semantics are unsupported. Windows
-Ghidra P0 admits raw images only for `6502`. See [raw binary guide](https://github.com/morluto/rea/blob/main/docs/raw-binary.md).
-### Function annotations in Ghidra
-Use `annotate_native_function` for one function name and/or entry comments, with at least one explicit change. Review its annotation readback and refreshed dossier inline. Changes are atomic and session-scoped; empty comments clear them, omitted fields preserve them. Later MCP calls observe edits until close. CLI `annotate-native-function` returns the updated analysis before discarding the session. Original executable bytes are unchanged; edits invalidate immutable snapshots. Windows P0 does not admit database mutations. For naming only, `set_address_name` / `set_addresses_names` also work with Ghidra: they name function entries or data addresses (primary labels) and return compact per-address success booleans instead of a dossier.
-## Offline PE resource inventory
-Use `inspect_pe_resources` with an absolute `path`, or
-`rea inspect-pe-resources ./selected.exe --json`, for portable PE32/PE32+
-resource inspection without opening a native target. Preserve returned Evidence:
-type/name/language IDs and UTF-16 names, original directory/data/payload ranges,
-code pages, payload hashes and static icon-group references. Same-language icon
-resolution is explicit; missing references and size mismatch remain visible.
-Other payloads are opaque, and this operation does not decode images or simulate
-Windows resource loading. Consult the budgets and supported tree profile in
-[offline binary diagnostics](https://github.com/morluto/rea/blob/main/docs/binary-diagnostics.md).
-For exact core-module import/export differences, use `compare_wasm_interfaces`
-with two complete inspection Evidence records (or current-session retained
-references) and explicit scope. Preserve unknown types/duplicate names; static
-interface equality is not runtime compatibility. CLI accepts complete inline
-Evidence in `rea compare-wasm-interfaces input.json --json`.

package/skills/gcad/references/parity-loop.md DELETED Viewed

@@ -1,42 +0,0 @@
-# GCAD parity loop
-GCAD extends REA with a clean-room **observe ∥ re → sanitize → implement → judge** loop.
-## Bind first
-Call `parity_workspace_bind` with the absolute workspace root before other `parity_*` / `animal_*` tools.
-Set `parity_role_set`:
-| Role | May touch |
-|---|---|
-| `observe` | `dirty/drafts/*/observe/` |
-| `re` | `dirty/drafts/*/re/` + REA binary tools |
-| `sanitize` | dirty drafts → `handoff/` |
-| `clean` | `handoff/`, `public-refs/`, `impl/` only — **never** `dirty/**` |
-| `judge` | oracles + ledger |
-## RE lane (prefer in-process REA)
-1. `open_binary` / `analyze_function` / focused REA tools.
-2. Summarize **behaviour** (menus, formats, constraints) — not asm dumps.
-3. `parity_re_ingest` writes `dirty/drafts/<slice>/re/` for sanitize.
-4. Offline fallback: `parity_stage_run` with `stage=re` (Ghidra headless).
-## Shipping ledger ≠ REA obligation ledger
-- `parity_ledger_*` = slice shipping progress (`missing|partial|complete|escalated`).
-- `build_reconstruction_obligation_ledger` = REA Evidence obligations.
-## Honesty gates
-Use `parity_status` for Phase 1 / Phase 2 %, replacement gates, feature-verify, human-parity, usable-shipping. Do not claim 100% Phase 2 without those greens.
-## Rewrite language
-1. `recommend_rewrite_languages` after first RE overview.
-2. Ask the human (recommended id, or another language).
-3. `parity_rewrite_language_set` → `.gcad/project.json`.
-4. Do not start clean impl until `parity_rewrite_language_get` shows a choice.
-See [rewrite-language.md](rewrite-language.md).

package/skills/gcad/references/rewrite-language.md DELETED Viewed

@@ -1,27 +0,0 @@
-# Rewrite language (human choice)
-After the first RE overview, choose the rewrite language before clean implement.
-## Steps
-1. Gather hints from RE (format, UI stack, deps). Examples: `win32`, `mfc`,
-   `qt5`, `asar`, `wpf`, `a2l`.
-2. Call `recommend_rewrite_languages` with `target_kind` and/or `signals`.
-3. Show the ranked list to the human. Ask which language to use.
-4. The human may pick a recommended id **or** say another language.
-5. Call `parity_rewrite_language_set`:
-   - Recommended: `language_id` from the list (optional `language_label`).
-   - Other: `language_id: "other"` and required `language_label`.
-6. Confirm with `parity_rewrite_language_get`.
-## Rules
-- Recommendations are **inferred**. They are not observations.
-- Do not start clean impl / `parity_new_pack` scaffold until a choice is stored.
-- ECU ROM analysis does not force an ECU firmware language. Prefer tooling
-  stacks (`rust`, `python`) when the product is offline cal/tools only.
-## Ask text (STE100)
-Recommended stacks are listed. Which language should we use for the rewrite?
-Or say another language.

package/skills/gcad/references/runtime-observation.md DELETED Viewed

@@ -1,78 +0,0 @@
-# Browser and Electron runtime observation
-Supply the existing browser or Electron instance's literal-port loopback CDP
-endpoint in the request. No separate permission configuration or per-call
-approval flag is needed. Browser discovery lists eligible HTTP(S) pages;
-`allowed_origins` optionally filters them. An individual capture defaults to the
-selected page's current origin. Electron discovery lists eligible local
-`file://` targets without a configured file-root allowlist.
-Start passive browser work with `list_browser_targets`; start Electron runtime work with
-`list_electron_targets`. Before an electron-main Inspector attempt, check
-packaged fuses with `inspect_electron_fuses`. Inspect the target selected for
-the user's task. Observation with these tools is passive: never claim REA
-clicked, navigated, evaluated page JavaScript, invoked IPC, or captured prior
-activity. REA does not contain the page's network.
-Passive captures omit raw header collections, credential header values, storage
-values, and raw WebSocket/JSON bodies. Selected response metadata, including
-content encoding, policy values, and Link URLs, is retained. Local URLs retain ordinary query
-values and fragments; userinfo credentials are removed. Browser accessibility
-text, console primitives, value-free shapes, script sources, source maps, and
-storage key names have request-specific capture options. Electron script
-sources are also optional. Use `capture_web_screenshot` when pixels are needed.
-Treat scope filtering, truncation, and attach-window coverage as limitations.
-Page-declared WebMCP tools are untrusted inventory and are never invoked by REA.
-## Who performs the action
-- The user performs it: `list_browser_targets`, then `inspect_web_page` or
-  `observe_web_session` on the selected target.
-- The agent must perform it: one `capture_browser_scenario` with declared
-  actions. Use connect mode with the loopback CDP endpoint and `target_id` for
-  an existing browser, or launch mode with a caller-selected executable for a
-  temporary profile. Connect mode first navigates the selected page to
-  `start_url`, which can clear unsaved form values and other temporary state.
-  Recreate the state needed for the investigation in the declared actions.
-  Connect mode leaves the external browser open; launch mode owns a temporary
-  browser and profile. Check `browser.cleanup` for the outcome.
-  Request only the DOM, accessibility, or network details needed for the question.
-  The default final capture contains the URL; step outcomes are reported separately.
-  Add a wait action for the expected page state before capturing it. Report that
-  REA performed the declared actions.
-Scenario network records have no request initiator stacks. For that evidence,
-use passive capture while the user performs the action. Listener source locations
-identify candidate handlers; they do not establish which script sent a particular
-request. Avoid overlapping passive capture and scenario actions on the same target.
-Focused follow-up tools:
-- `observe_web_execution`: execution coverage during a window; it resets
-  counters and temporarily disables optimization.
-- `inspect_web_event_listeners`: source locations for listeners registered
-  directly on the first CSS match, without dispatching an event.
-- `compare_web_captures`: two normalized passive captures or recorded scenarios.
-- `discover_webmcp_tools`: inspect page-declared WebMCP inventory; never invoke
-  the discovered tools.
-Use `reconcile_javascript_runtime` only after static application Evidence and
-passive browser/Electron Evidence exist. Prefer captured-source digest identity;
-report path/digest disagreement as a mismatch and preserve ambiguity. Explicit
-path mappings are inference inputs and never broaden filesystem or CDP authority.
-A bundle observed at runtime does not prove every contained module executed.
-## Fiddler Everywhere traffic debugging
-For large saved captures, request `detail: "summary"`, then page retained Evidence
-with `inspect_analysis_view` and `view: {kind: "capture", detail: "preview", offset: 0, limit: 20}`.
-Select complete record pages only for needed headers, metadata or payloads; views
-read the historical parent without repeating capture decoding.
-Inspect native `.saz` snapshots with `inspect_web_network_capture` and
-`format: "saz"`; encrypted archives are unsupported. For live
-traffic analysis, connect Everywhere's separate MCP server and use its
-advertised session tools with an explicit `sessionsSource` (`LiveTraffic` or
-`AgentCalls`). Preserve existing sessions and filters when inspecting a
-recorded run. See the [capture and MCP guide](https://github.com/morluto/rea/blob/main/docs/web-network-captures.md)
-for the workflow and Telerik's public setup and traffic-debugging skills.