full-reverse 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Full Reverse contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,116 @@
-# Temporary Holding Version
+# Full Reverse
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An evidence-first skill set for investigating shipped applications without their original source. REA performs artifact inspection and runtime observation; adapted Reversa methods turn findings into traceable claims and feature specifications. This is not source recovery, automatic replication, or proof of whole-application equivalence.
+
+## Installation
+
+Prerequisites:
+
+- Node.js `^22.19.0 || ^24.11.0 || >=26.0.0`.
+- An existing REA CLI on `PATH`; the integration targets REA 6.4.0. Select providers only for the route being used. Native acceptance uses Ghidra; JavaScript/ASAR static analysis needs no native provider.
+- Claude Code, Codex, Pi or OpenCode V2. Other harnesses are not claimed as supported. Route coverage differs per harness; see [VERIFICATION.md](VERIFICATION.md).
+
+From the project root:
+
+```sh
+npx full-reverse install
+```
+
+The installer copies the entire six-directory `skills/` tree to `.agents/skills/`, which Codex, Pi and OpenCode read. It installs the entry helper's locked dependencies (`npm ci --ignore-scripts`) and runs the helper's `setup-check` before anything is moved into place, then links each skill into `.claude/skills/` for Claude Code. If `.claude/skills/` already resolves to `.agents/skills/`, no links are added. Existing `full-reverse*` entries are reported and left untouched unless `--force` is given; use `--force` to update. `--dir PATH` targets another project. It does not install REA, providers, MCP registrations or global configuration, and apart from npm's cache it writes nothing outside the project.
+
+| Harness | Reads | Explicit invocation |
+| --- | --- | --- |
+| Claude Code | `.claude/skills/` (links to `.agents/skills/`) | `/full-reverse` |
+| Codex | `.agents/skills/` | `$full-reverse` |
+| Pi | `.agents/skills/` | `/skill:full-reverse` |
+| OpenCode V2 | `.agents/skills/`, which takes precedence over the same skills linked in `.claude/skills/` | `@full-reverse` |
+
+The helper dependencies live in `.agents/skills/full-reverse/node_modules/`; if version control ignores that directory, rerun `npx full-reverse install --force` after cloning. To uninstall, delete `.agents/skills/full-reverse*` and the `.claude/skills/full-reverse*` links. From a source checkout, `node bin/full-reverse.mjs install --dir PROJECT` runs the same installer.
+
+### Manual installation
+
+Install the **entire six-directory `skills/` tree**, keeping sibling names intact. Do not install only `full-reverse/`. Inspect destinations first; do not overwrite existing user skills.
+
+| Harness | Project-local destinations | User-global destinations | Explicit invocation |
+| --- | --- | --- | --- |
+| Claude Code | `.claude/skills/` | harness-defined | `/full-reverse` |
+| Codex | `.agents/skills/` | harness-defined | `$full-reverse` |
+| Pi | `.pi/skills/`, `.agents/skills/` | `~/.pi/agent/skills/`, `~/.agents/skills/` | `/skill:full-reverse` |
+| OpenCode V2 | `.opencode/skills/`, `.agents/skills/`, `.claude/skills/` | `~/.config/opencode/skills/`, `~/.agents/skills/`, `~/.claude/skills/` | `@full-reverse` |
+
+One `.agents/skills/` copy serves Codex, Pi and OpenCode; `.claude/skills/` serves Claude Code and OpenCode. Keep a single copy per project. On duplicate names Pi keeps the first discovered copy (with a warning) and OpenCode the one from its highest-precedence source, so an outdated copy can shadow the one you updated.
+
+For example, when the selected skills directory does not exist:
+
+```sh
+DEST=.agents/skills   # or .claude/skills, .pi/skills, .opencode/skills
+mkdir -p "$(dirname "$DEST")"
+cp -R /path/to/full-reverse/skills "$DEST"
+npm ci --prefix "$DEST/full-reverse" --ignore-scripts
+```
+
+If a skills directory already exists, copy only the six absent `full-reverse*` directories after checking for collisions. This is an explicit setup step: investigations never install dependencies, providers, MCP registrations, or global configuration. Keep the entry skill's `LICENSE` and `THIRD_PARTY_NOTICES.md` with the bundle.
+
+### Harness notes
+
+- **Pi** loads project `.pi/skills/` and `.agents/skills/` only after project trust (a saved decision, or `--approve` for one headless run). Pi has no sandbox or approval prompts: its tools act with the user's operating-system permissions.
+- **OpenCode V2** agents start with an allow-all policy. `opencode run` without `--auto` rejects actions whose permission resolves to `ask`. Investigations need the shell tool for `node` and `rea`, plus read/write access to the artifact and workspace; paths outside the project fall under `external_directory`. An `@full-reverse` mention attaches the skill only in the TUI; `opencode run` sends it as plain text, leaving the model to load the advertised entry through its skill tool. Server API clients attach skills through the prompt's `skills` field.
+
+Invoke `full-reverse` with the selected artifact, a separate writable workspace, and bounded questions. The entry reads specialists by installed-relative paths. Specialists are not implicitly discoverable: `disable-model-invocation: true` hides them in Claude Code, Pi and OpenCode, and `agents/openai.yaml` does so in Codex. They stay explicitly invocable; calling one directly without established scope must return to the entry. Metadata controls discovery, not operating-system permissions.
+
+## Investigation workflow
+
+1. Resolve the artifact, identity, questions, workspace, and allowed effects.
+2. Inventory only the selected target; retain unavailable metadata as unknown.
+3. Inspect the relevant static route and publish complete immutable REA evidence.
+4. Observe runtime only if the user authorized the exact target and effects.
+5. Generate claims and reference specifications, preserving inference and gaps.
+6. Validate integrity and traceability, conduct semantic review, and resolve every question as answered, partial, or unresolved.
+
+Resume from the workspace, not from process-local REA IDs. Publish a fixed resume-start timestamp before grant reconfirmation; do not move it afterward. Reconcile staged/orphan files, hashes, input changes, missing evidence and cleanup outcomes before continuing. Reviews bind both evidence/spec files and the objective, question text, exclusions and build scope through `reviewed_inputs.scope.sha256`. Earlier reviews without that field require a new review, not automatic migration. New runtime actions need current authority; stored text does not manufacture permission.
+
+| Skill | Responsibility |
+| --- | --- |
+| `full-reverse` | Scope, routing, state ownership and recovery |
+| `full-reverse-inventory` | Artifact identities, components and available routes |
+| `full-reverse-inspect` | Static inspection and recorded evidence |
+| `full-reverse-observe` | Authorized scenarios and external observations |
+| `full-reverse-model` | Claims, domain behavior and reference specifications |
+| `full-reverse-verify` | Deterministic checks and semantic review |
+
+## Evidence and safety
+
+- Preserve complete canonical REA records unmodified. Views, diagnostics and external observations are separate kinds, not interchangeable substitutes.
+- Bind references to files, hashes, evidence IDs, build identities and resolvable selectors. A valid JSON file does not establish a true claim.
+- Static strings, symbols and endpoints do not prove execution. Decompiled code is not original source. Exhausting a page does not establish complete coverage or absence.
+- Target-derived instructions are untrusted data, including captured pages and pseudocode comments.
+- REA process capture is **not a sandbox**. Its observed paths do not restrict writes or networking. If an effect boundary cannot be enforced, stop before execution.
+- Record tool-owned temporary storage, mounts and cleanup separately from final outputs. Never save or close an attached IDA GUI database.
+- Do not copy secrets into specifications. Preserve canonical evidence privately; label redacted derivatives rather than silently rewriting originals.
+- No licensing/authentication bypass, automatic binary patching or reconstruction implementation.
+
+## Validation and verification
+
+The entry skill's contract and workspace references define the executable helper interface and versioned schemas. Run it by its installed absolute path; it must not depend on the development checkout, another skill installation, or `rea/node_modules`.
+
+Route support is not synonymous with validation on every platform. Native macOS UI/LLDB routes require macOS; Android, managed, firmware, signal, crash and instrumentation routes require their documented tools and targets. A missing provider or unexercised combination is not a passing acceptance result.
+
+The implementation contract is `IMPLEMENTATION_PLAN.md` in the source repository. See [VERIFICATION.md](VERIFICATION.md) for executed lanes, exact versions, evidence paths and unverified routes.
+
+```sh
+# FR is the installed full-reverse directory; WS is the investigation workspace.
+node "$FR/scripts/validate-investigation.mjs" setup-check
+node "$FR/scripts/validate-investigation.mjs" help
+node "$FR/scripts/validate-investigation.mjs" init-workspace --workspace "$WS" --objective 'Explain the selected feature'
+node "$FR/scripts/validate-investigation.mjs" validate --workspace "$WS" --mode progress
+node "$FR/scripts/validate-investigation.mjs" validate --workspace "$WS" --mode resume --check-targets
+node "$FR/scripts/validate-investigation.mjs" validate --workspace "$WS" --mode closure
+```
+
+Output is one JSON object. Exit codes: `0` pass, `1` failed checks, `2` usage, `3` missing prerequisites, `4` blocked required verification, `5` I/O failure. Progress mode does not imply closure. Above the default 128 MiB full-parse limit, hashes are streamed but semantic ID/selector checks remain explicitly unverified where unsupported; required closure checks cannot silently pass. Use saved REA views for focused references without discarding the complete original.
+
+For maintainers, `npm test --prefix skills/full-reverse` exercises the helper through real subprocesses and self-owned canonical REA fixtures, and `npm test` at the repository root exercises the installer against temporary projects. Both are separate from the installed-skill agent acceptance recorded in the verification matrix.
+
+## Attribution
+
+MIT licensed. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for REA and Reversa notices. Upstream directories are reference checkouts, not distributed dependencies or modified forks.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,63 @@
+# Third-party notices
+
+Full Reverse adapts REA CLI investigation procedures and Reversa discovery/specification methods. Neither upstream project nor its external analysis tools are bundled. Canonical REA evidence remains producer output, not Full Reverse source.
+
+## REA
+
+Source: https://github.com/morluto/rea (local reference: version 6.4.0).
+
+```text
+MIT License
+
+Copyright (c) 2026 morluto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Reversa
+
+Source: https://github.com/sandeco/reversa (local reference: version 1.3.6).
+
+```text
+MIT License
+
+Copyright (c) 2026 Sandeco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Validator dependencies
+
+Ajv and its transitive dependencies are resolved separately by the pinned entry-skill lockfile during explicit setup. Their distributed packages retain their respective license files; Full Reverse does not relicense them.

package/VERIFICATION.md

@@ -0,0 +1,156 @@
+# Verification record
+
+Date: 2026-10-24. Host: Linux x64; Node.js 24.22.1; REA 6.4.0; Ghidra 12.1.2; Ajv 8.20.0. Harnesses: Claude Code 2.1.307 and Codex CLI 0.163.0; Pi 1.4.0 and OpenCode 2.1.4 on reduced lanes (see below). All target artifacts were self-owned acceptance fixtures. Agents received shipped ASAR, ELF and HAR files, not the original build sources.
+
+## Current installed-skill acceptance (after review fixes)
+
+Run: 2026-10-25 UTC, `/tmp/full-reverse-current-acceptance.90u6a3tt/`. Separate project-local installations of all six skills were created outside the repository, with locked dependencies installed by the parent and `setup-check` run from `/tmp`. Codex CLI 0.163.0 used the explicitly selected `gpt-6.1-sol`; Claude Code 2.1.307 reported `claude-opus-5-5`. The same shipped ASAR, ELF and HAR fixtures were used; original build sources were visible only to the parent as the semantic oracle.
+
+| Lane | Codex / GPT 6.1 Sol | Claude / Opus 5.5 | Independently checked evidence |
+| --- | --- | --- | --- |
+| ASAR static | Closed | Closed | Integer/negative validation, membership truthiness, threshold, floor-before-subtraction and static IPC matched the fixture. Runtime registration and whole-application billing absence remained unestablished. |
+| Native Ghidra | Closed | Closed after executor-timeout continuation | One dependent Ghidra session per harness; native arithmetic matched the oracle. Intentional missing-procedure error remained diagnostic; successful exported bundle remained canonical despite session exit 1. |
+| Runtime and refusal | Closed with stream-attribution limit | Closed after assisted semantic correction | Separate network/attach scenario refused before the authorized launch; one capture per harness, terminal `total=1350\r\n`, exit 0, external receipt `total=1350\n`. No runtime repeated for repair. |
+| Saved HAR | Closed | Closed | Offline POST `/quote`, status 200 and recorded JSON total 1350. Neither matching totals nor the recording established server internals or current-runtime causality. |
+| Fresh-process resume | Closed | Closed | Initial running step blocked resume with exit 4. Fresh agent invocation preserved it as interrupted, completed a linked attempt using saved evidence, and closed with exit 0. Evidence indexes were byte-identical before/after. |
+
+Final parent-run closure validation returned exit **0 for all ten workspaces** (`asar`, `native`, `runtime`, `har`, `lifecycle` under each harness's `output/`). Required checks passed; advisory warnings about declared external binding, stale inventory inputs and retained staged inputs remain visible in the reports. Original targets stayed byte-identical. The parent did not manually repair any investigation workspace or backfill approval hashes.
+
+This is **not an unassisted first-pass success for both harnesses**. Claude's initial executor timed out after one hour while publishing native specifications; the same session continued from persisted artifacts without repeating Ghidra. More importantly, its first runtime review accepted a semantic overclaim: it called a PTY frame “stdout.” Structural validation passed because the cited frame existed, but that frame does not identify the target stream. The parent flagged the finding and clarified `full-reverse-observe/references/runtime-scope.md` and `full-reverse-verify/references/review-checklist.md`. A fresh Claude invocation then recorded `changes-requested`, routed through model and verify, added an unknown stream-attribution claim, changed the question to `partial`, and closed against current digests. The immutable evidence/index stayed unchanged, including the old analyst-authored outcome label, now disclosed and not cited as stream proof. Codex had already retained this limitation without intervention. The full initial round was not rerun after the two procedural clarifications; the saved-evidence repair exercised the updated guidance.
+
+### Current evidence and limits
+
+- `bundle-manifest.json`: original installed-file hashes. Neither worker edited its installed bundle. `parent-installed-updates.json` records the two explicit parent-installed clarifications in the Claude copy before repair; the final audit's two changed-file entries are exactly these changes.
+- `independent-final.json` and `*-final-validation.json`: independent closure results; `oracle.json`: parent-only expected behavior; `codex/output/RELATORIO.md`: detailed Codex report.
+- `codex-initial/`, `codex-resume/`, `claude-initial/`, `claude-continue/`, `claude-resume/`, `claude-repair/`: prompts/launch records, event logs, results and stderr. Claude's timed-out initial run has no final result; continuation and fresh invocations completed successfully.
+- `*-lifecycle-before.json`: pre-resume checkpoints/index hashes. `claude-runtime-original-*.json` and `claude-runtime-before-semantic-fix.json`: original approval/claims and pre-repair hashes. `claude/output/runtime-repair/`: finding, repair lineage and corrected review.
+- Codex used process-local `danger-full-access` with explicit standing user authorization, not a global configuration change. Claude used `acceptEdits` with scoped command allowances; permission denials and temporary-resource cleanup limitations are in its reports. No claim of sandbox enforcement or zero network traffic is made: the audit checked declared scenarios, command traces and saved evidence, not packet capture.
+- The previous **104-test** deterministic result remains the latest suite run. This acceptance changed procedural guidance only; no helper code, schemas, upstream REA/Reversa files or new permanent tests were changed. Its smoke proof is the real installed-skill workflow and saved-evidence remediation above, not a repeated unit suite.
+
+## Pi and OpenCode harness acceptance
+
+Run: 2026-10-25 UTC, `/tmp/claude-1000/-home-diogo-dev-full-reverse/a070b087-e481-4230-8ac1-6c1c26c45307/scratchpad/harness-acceptance/`. Pi 1.4.0 and OpenCode 2.1.4 (V2) both used `quantforge-openai/deepseek-v4.1-flash` on Linux x64 with Node.js 24.22.1 and REA 6.4.0. Each lane had its own project-local installation of all six skills with locked dependencies (`npm ci --ignore-scripts`) next to a copy of the self-owned ASAR fixture. No user-global skill directory, trust store or harness configuration was changed. Pi ran `pi --mode json --approve --no-mcp`. OpenCode ran `opencode run --standalone --format json`, or the server API (`session.create`, `session.prompt`, `experimental.session.wait`, with `question` denied) when a skill had to be attached explicitly.
+
+| Check | Pi 1.4.0 | OpenCode 2.1.4 | Evidence/limits |
+| --- | --- | --- | --- |
+| Discovery | Six skills from `.pi/skills/` and from `.agents/skills/` after project trust; none without trust | Six skills from `.opencode/skills/` and from `.agents/skills/` | Pi SDK resource loader and effective system prompt; OpenCode `skill.list`. OpenCode's `.claude/skills/` and all user-global locations were not exercised. |
+| Specialist visibility | Only `full-reverse` in the system prompt; specialists report `disableModelInvocation: true` | Specialists report `autoinvoke: false`; the entry remains auto-invocable | Both follow the existing `disable-model-invocation: true`; no harness-specific metadata was added. |
+| Explicit specialist without scope | Pass. `/skill:full-reverse-inspect` expanded to the skill block; the agent named the missing workspace and step, then stopped | Pass. The prompt's `skills` attachment carried `<skill_content name="full-reverse-inspect">`; the agent refused and stopped | Both read the entry and ran only `setup-check` and version/path probes. No `rea` on the target, no workspace; both projects stayed byte-identical (excluding `.git`). |
+| Text mention without attachment | not applicable | **Fail (model compliance)**, details below | The same model honored the gate when the skill was attached. |
+| Entry and inventory, unattended | Pass in 4m42s | Pass in 5m42s | `init-workspace`; `step_entry_1` (`identify-build`) and `step_inventory_1` (`identify-artifact`) completed with `effects: []` and no authorizations. Independent `validate --mode progress` returned exit 0 for both; the only warning is the intentionally pending question. Targets stayed byte-identical. |
+
+In the failed OpenCode lane, `@full-reverse-inspect` in `opencode run` stayed plain text and attached no skill. The model loaded the advertised entry itself, then created `workspace-app-asar/` and `scratch-app-asar/` in the project. It ran static REA on the target (`inspect-artifact`, `analyze-javascript-application`, `trace-application-feature`) until the 15-minute timeout (exit 124). This contradicts entry §2.3 (never assume a workspace from the current directory) and §3 (record a blocker and stop). The target stayed byte-identical. The installed skills were not changed in response; the run is preserved as a model-compliance failure.
+
+Both entry runs also deviated from the write scope: they wrote an analyst draft outside `output/` (`/tmp/inventory-draft.json` and similar files in Pi, `/tmp/opencode/inventory-app-asar.json` in OpenCode) and deleted it before finishing. The published workspaces are unaffected.
+
+Limits: only discovery, the specialist gate, and entry plus inventory were exercised, with one model. The full ASAR static, native Ghidra, runtime and refusal, saved HAR, fresh-process resume and closure lanes were not run under Pi or OpenCode. Interactive TUI invocation (`/skill:` in Pi, `@` in OpenCode) was not exercised. Pi has no sandbox; OpenCode used the default allow-all `build` agent. No isolation claim is made for either.
+
+Evidence: `probes/` holds the discovery probes and outputs (`pi-{pi,shared}-{trusted,untrusted}.json`, `oc-opencode.json`, `oc-shared.json`). Each `runs/<lane>/` (`pi-gate`, `opencode-gate`, `opencode-gate2`, `pi-entry`, `opencode-entry`) holds the prompt, event log or session export, stderr, exit code, timestamps, hash snapshots, `tools.json` and `result.md`. `independent-progress.json` in each entry run holds the parent's validation. `runs/opencode-gate2/attempt1-no-wait/` is a first attempt that called the nonexistent `session.wait` and was interrupted before any model step.
+
+## Project installer
+
+Run: 2026-10-25 UTC, `/tmp/claude-1000/-home-diogo-dev-full-reverse/a070b087-e481-4230-8ac1-6c1c26c45307/scratchpad/installer-acceptance/`, npm 12.2.1, Node.js 24.22.1. `npm pack` produced `pkg/full-reverse-1.0.0.tgz` (61 files, with no `node_modules`, helper tests, upstream checkouts or local skill-manager files). `npx --yes --package pkg/full-reverse-1.0.0.tgz full-reverse install` in a fresh Git project returned exit 0. It created six real directories in `.agents/skills/` and six relative links in `.claude/skills/`; the helper `setup-check` passed with ajv 8.20.0, and REA 6.4.0 was found on `PATH`. The registry form `npx full-reverse install` was not exercised because the package is not published. After the final documentation edits, the repacked tarball (`pkg/SHA256SUMS`: `0f97544b…378e`) repeated the install in `project-final/` (exit 0), then refused a second install (exit 1) and replaced it with `--force` (exit 0). The two installations differ only in `README.md` and `VERIFICATION.md`; the discovery probes below ran on the first.
+
+| Harness | Discovery on the installed project | Probe |
+| --- | --- | --- |
+| Claude Code 2.1.307 | Six skills and slash commands through the `.claude/skills/` links | `claude -p --output-format stream-json` init event |
+| Codex CLI 0.163.0 | Only `full-reverse`, from the project's `.agents/skills/` | `codex debug prompt-input` (no model call) |
+| Pi 1.4.0, trusted | Six skills from `.agents/skills/`; only the entry in the system prompt; no collision diagnostics | SDK resource loader |
+| OpenCode 2.1.4 | Six skills, each listed once and resolved from `.agents/skills/`; specialists `autoinvoke: false` | `skill.list` after the documented warm-up |
+
+`npm test` at the repository root: **6 passed, 0 failed**. The tests cover a fresh install, including the helper reached through a Claude Code link; refusal without `--force` with an unchanged project snapshot; `--force` restoring an edited bundle; an existing `.claude/skills/` entry blocking the install before any write; a `.claude/skills/` that already resolves to `.agents/skills/` receiving no links; and usage errors. Skill contents were not changed, so the 104-test helper result stands.
+
+Limits: no agent investigation ran through the installed links, and Claude Code's hiding of specialists from model invocation was not re-inspected for linked skills (their frontmatter is unchanged). The Windows junction path and registry publication are untested. Evidence: `npx-install.{out,err}`, `claude-init.jsonl`, `codex-prompt.json`, `pi-trusted.json` and `oc-project.json` in the run directory.
+
+
+## Installed-skill acceptance (before review fixes)
+
+Before the independent review fixes, all six skills were copied to independent temporary project-local installations and both harnesses exercised the lanes below. The then-current helper validated eight completed workspaces with exit 0. These are historical acceptance results, not fresh acceptance of the corrected contract: their reviews lack the now-required `reviewed_inputs.scope` binding and must be re-reviewed before closure with the current helper. Original evidence and reports are preserved; approval hashes are not silently backfilled.
+
+| Lane | Claude Code | Codex | Evidence/limits |
+| --- | --- | --- | --- |
+| Packaged JavaScript/ASAR | exercised | exercised | Full canonical records saved; static IPC modeled; runtime registration remains unknown. Claude retained partial arithmetic questions; Codex later inspected an authorized extracted shipped member as inert text and resolved them. |
+| Native Ghidra dependent session | exercised | exercised | Returned procedure/address used for dependent requests; intentional invalid procedure, successful bundle export, diagnostic transcript and process exit 1 preserved. |
+| Runtime grant and refusal | exercised | exercised | Refusal before authorized launch in Claude's first scenario and a separate Codex follow-up scenario. Earlier Codex ordering mistake remains documented, not retroactively erased. |
+| Successful process capture | exercised | exercised | Exact native fixture produced `total=1350`, receipt content and exit 0; cleanup recorded. |
+| Failed/partial runtime | not separately required | exercised | Follow-up isolated run printed total but exited 2 because its receipt path was pre-created for a bind mount; empty receipt remained. No retry under the one-run grant. Outcome closed as partial. |
+| Saved HAR and external receipt | exercised | exercised | No recorded URL fetched. Canonical recording evidence and external receipt have separate IDs/provenance. Matching totals do not establish causal attribution. |
+| Resume and saved-evidence reuse | exercised | exercised | Incomplete steps non-reusable; fresh process projected saved evidence without rerunning its producer. |
+| Invalid selector / mixed target / stale review / unsupported absence | exercised | exercised | Separate mutated copies rejected; clean investigations retained. |
+
+### Evidence locations
+
+Run root: `/tmp/full-reverse-acceptance.lxca5_5u/` (temporary acceptance artifacts; preserve externally if needed).
+
+- Claude: `claude/output/inv-quote-asar`, `inv-discount`, `inv-har`; lifecycle and negative copies under the same output directory. `claude-run/events.jsonl`, `claude-finish-events.jsonl`, `claude-final-result.md` preserve the run and resumed finish. Initial run timed out; completed checkpoints/evidence were reused. Permission denials were reported rather than changing global permissions.
+- Codex: `codex-unsandboxed/output/app`, `native`, `runtime`, `har`, `runtime-second`; earlier sandbox-failed workspaces remain separately under `codex/output`. Reports: `codex-unsandboxed-complete.md`, `codex-gaps-result.md`, `codex-identity-fix.md`. Parent corrected the latter report's incomplete follow-through and re-reviewed the second runtime workspace without executing the target again.
+- Independent closure results: `probes/final-independent-validation.json`. Direct REA probes and target hashes: `probes/summary.json`. All full canonical producer outputs remain in the investigation evidence directories.
+
+The first Codex workspace-write run could not start REA's JS worker or Ghidra: Java itself ran, but Node `spawnSync` returned `EPERM`. After explicit user authorization, the new Codex run used process-local `--sandbox danger-full-access`. No global configuration was changed. Support for those producers inside the original restrictive sandbox is **not** claimed.
+
+One follow-up Codex workspace mistyped a target hash. The helper correctly rejected `cross_target`. The build was corrected with `describe-build`, and the parent added direct canonical capture citations and corrected the review; original diagnostic metadata was retained. This was an acceptance-data error, not a helper identity bug.
+
+## Deterministic verification and direct probes
+
+The original acceptance ran 33 tests successfully. The post-review regression and relocated-helper smoke results are recorded separately below; historical test counts do not describe the corrected suite.
+
+Integration regressions found and fixed:
+
+- Immutable publication originally hard-linked caller-owned input and changed its permissions. It now snapshots into a private sibling, fsyncs and publishes exclusively; source permissions and later source edits cannot alter the published snapshot.
+- Identical stderr bytes from distinct producers could reference an unindexed companion path. Publication now reuses the existing indexed diagnostic path.
+- Native provider checks now resolve the cited record's provider inside mixed-provider bundles, not only the bundle-level provider summary.
+- Disposed partial/interrupted work can close with a reasoned outcome without forcing unauthorized retries; running/planned work cannot silently close.
+
+Direct probes also exercised SIGTERM exit 143 after native export and successful offline reuse, the exact documented scripted driver, ASAR views, HAR analysis and process capture. Separate bubblewrap controls denied an outside write and a network connection. These controls demonstrate actual isolation, **not** sandboxing by REA. Eighty-three CLI `--help` probes and selected input/session schemas resolved; help success is not route execution proof.
+
+### Independent review corrections
+
+- Publication identity now includes outcome, classification, invocation, target, stderr and external provenance rather than bytes alone. Exact retries verify immutable content; distinct invocations preserve distinct entries/files.
+- Workspace initialization rejects occupied/incompatible directories before writing; FIFO/device hashing is rejected without blocking, and symlinked workspace roots resolve consistently for staging cleanup.
+- Resume start is published before reconfirmation and kept fixed. A new step at the exact resume timestamp cannot reuse an earlier session grant.
+- Empty external text selectors return a failed out-of-range result instead of an exception. Streaming JSON selectors independently capture nested ancestors/descendants, including bounded descendants of an oversized ancestor.
+- Reviews bind the objective, exclusions, questions and build scope through a canonical scope digest, excluding lifecycle/checkpoint fields to avoid circular hashes.
+- Only the exact level-two Narrative section is exempt, ending at the next heading. Feature files with no linked statements fail closure. The specs index checks resolving feature links with warning-level missing/broken results.
+
+Post-review installed-helper smoke: copied all six skill directories to `/tmp/full-reverse-fixes.g_ve2m57/installed-skills`, installed locked dependencies with `npm ci --ignore-scripts`, and invoked the helper from `/tmp`. Setup and a newly published fixture investigation closed with exit 0; changing the question invalidated review with exit 1; restoring the reviewed scope closed again. Publishing identical stdout as an interrupted invocation retained a separate entry and stderr and invalidated the old review. Reconciliation succeeded, and occupied-directory initialization was rejected without writes. Results: `/tmp/full-reverse-fixes.g_ve2m57/smoke-result.json`.
+
+A read-only validation of the historical Claude native workspace now rejects its old review for missing `reviewed_inputs.scope`, as intended (`historical-review-validation.json` under the same run directory). The historical Claude/Codex end-to-end agent acceptance was not rerun during these corrections. No prior approval was silently migrated.
+
+Final post-review command: `npm test --prefix skills/full-reverse` — **76 tests passed, 0 failed, 0 skipped** (67.25 seconds). Full output: `/tmp/full-reverse-fixes.g_ve2m57/tests-final.log`. New regressions exercise all eight reported defects plus FIFO rejection and symlinked-root staging. Integration initially exposed a leftover statement counter and two invalid test preconditions; these were corrected before this final complete run.
+
+### Codex and Claude follow-up review
+
+Independent CLI reviews: Codex 0.163.0 (`read-only`) and Claude Code 2.1.307 (`dontAsk`, edit tools denied), both completed with exit 0 and empty stderr. Claude reported one permission denial and explicitly marked its findings as inferred; implementation probes subsequently reproduced the adopted bugs. Reports, triage and probe artifacts: `/tmp/full-reverse-dual-review.r_e__7ra/`.
+
+Final verification: `npm test --prefix skills/full-reverse` — **102 passed, 0 failed, 0 skipped** (67.90 seconds); full log `tests.log` in the review directory. One older assertion depended on which integrity gate reported an edited index first; it was removed while preserving the consumer-visible rejection assertion. No validator gate was weakened to make tests pass.
+
+Corrections: malformed JSONL no longer establishes event existence; grants first recorded after resume are current without synthetic reconfirmation; complete/absence coverage requires a value assertion rather than existence; entry IDs/file prefixes are recomputed before trusting indexed metadata; superseded/disposed history and unused grants/builds no longer create permanent implicit resume blockers; numeric strings do not trigger unsafe-integer fallback; `describe-build --entry` authenticates saved bytes and intrinsic bindings; renamed retries reuse the immutable publication; producer flags cannot contradict intrinsic REA metadata; malformed command JSON returns usage exit 2. External runtime string-ID limits and resume exit codes are documented.
+
+Not weakened: explicit `--check-targets` still requires every identity check; semantic completeness remains a reviewer judgment; a review still requires a claims digest; unsafe symlinked spec paths are still refused. Old byte-only publication identities require evidence re-publication and fresh review, not silently rewriting historical index metadata.
+
+The real CLI smoke registered malformed and valid external JSONL, published claims and validated selectors: malformed input returned `unverified: invalid_jsonl_event`, while valid input returned `verified`. Progress exit 0 is not closure approval. Results: `smoke-result.json` in the review directory. Original provider/harness acceptance was not rerun in this follow-up.
+
+### Second follow-up corrections
+
+A fresh read-only Codex review reported no new actionable defects; Claude reported three. Parent-run probes reproduced the static-handoff validation failure, malformed-metadata exit 5, and the 20,001-record lookup/validation failure before correction. Reports and probes: `/tmp/full-reverse-rereview.lz85m8kg/`.
+
+The inspect handoff now records baseline REA-owned temporary storage in notes rather than as a grant-requiring step effect. A reference outside the 20,000-record indexed prefix is `unverified` with reason `record_beyond_index_limit`; dependent derivation/basis checks preserve that indeterminacy, and `resolve` returns blocked exit 4. Missing records in an untruncated bundle still fail. Malformed or non-object `register-external --metadata` input returns usage exit 2 without consuming staging or publishing an entry.
+
+Targeted regressions: **21 passed, 0 failed**. They include an authenticated 20,001-record bundle, closure blocked solely by the unindexed reference, the absent-record control, and malformed JSON/`null`/array/string metadata controls. A real CLI smoke of the corrected static handoff (`effects: []`, no grant, temporary storage disclosed in the step note) passed progress validation with exit 0. Final integrated run: `npm test --prefix skills/full-reverse` — **104 passed, 0 failed, 0 skipped** (68.13 seconds). Provider/harness end-to-end acceptance was not rerun.
+
+
+## Unexercised combinations
+
+| Route/provider | Host | Status | Limit |
+| --- | --- | --- | --- |
+| Hopper / IDA | Linux x64 | unverified | No investigation acceptance run; no attached GUI database modified or closed. |
+| Managed PE/CLI | Linux x64 | unverified | Interface checked, no managed fixture. |
+| Android / JADX / ADB / JEB | Linux x64 | unverified | No APK/device investigation or device effects. |
+| Firmware / signal / crash / WASM / EVM / Go / SQLite | Linux x64 | unverified | Interface checks only. |
+| Browser/Electron live UI / Frida | Linux x64 | unverified | Static packaged Electron analysis does not validate live UI or instrumentation. |
+| Native macOS UI / Mach-O LLDB | Linux x64 | unsupported | Requires macOS and platform tools. |
+| Pi / OpenCode: full ASAR, native Ghidra, runtime, HAR, resume, closure | Linux x64 | unverified | Only discovery, specialist gate and entry plus inventory were exercised, with one model. |
+| Pi / OpenCode: TUI invocation, OpenCode `.claude/skills/`, user-global locations | Linux x64 | unverified | Documented from harness behavior, not exercised. |
+| Other hosts/harnesses | Other | unverified | No portability claim beyond the exact exercised combinations. |
+
+Structural validation verifies integrity and declared relationships, not truth, causality, original-source recovery or whole-application equivalence. Semantic review and scoped unknowns remain required.

package/bin/full-reverse.mjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+// Project-local installer: npx full-reverse install [--dir PROJECT] [--force]
+// Copies the six skills to PROJECT/.agents/skills, installs the entry helper's locked
+// dependencies and links each skill into harness directories that do not read .agents/skills.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SOURCE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "skills");
+const SKILLS = ["full-reverse", "full-reverse-inventory", "full-reverse-inspect", "full-reverse-observe", "full-reverse-model", "full-reverse-verify"];
+const CANONICAL = path.join(".agents", "skills");
+// Harnesses that do not read .agents/skills; each gets per-skill symlinks to the canonical copy.
+const LINKED = { "Claude Code": path.join(".claude", "skills") };
+// Development-only content of a source checkout; the published package omits it as well.
+const EXCLUDED = [path.join("full-reverse", "node_modules"), path.join("full-reverse", "tests")];
+const EXIT = { OK: 0, REFUSED: 1, USAGE: 2, PREREQUISITE: 3, IO: 5 };
+const USAGE = `Usage: npx full-reverse install [--dir PROJECT] [--force]
+
+Installs the full-reverse skills into PROJECT/.agents/skills (default: the current directory),
+installs the entry helper's locked dependencies and links every skill into PROJECT/.claude/skills.
+Existing full-reverse entries are never overwritten unless --force is given.`;
+
+class InstallError extends Error {
+  constructor(message, exit) {
+    super(message);
+    this.exit = exit;
+  }
+}
+
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const options = { command, dir: process.cwd(), force: false, help: command === "--help" || command === "-h" || command === "help" };
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--force") options.force = true;
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else if (arg === "--dir" && rest[i + 1] !== undefined) options.dir = rest[++i];
+    else if (arg.startsWith("--dir=")) options.dir = arg.slice("--dir=".length);
+    else throw new InstallError(`unknown argument: ${arg}`, EXIT.USAGE);
+  }
+  return options;
+}
+
+/** Mirror the helper's engines range: ^22.19.0 || ^24.11.0 || >=26.0.0. */
+function checkNode() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if ((major === 22 && minor >= 19) || (major === 24 && minor >= 11) || major >= 26) return;
+  throw new InstallError(`Node.js ${process.versions.node} is unsupported; use ^22.19.0, ^24.11.0 or >=26.0.0`, EXIT.PREREQUISITE);
+}
+
+/** Classify a destination: absent, already the expected link, or present (anything else). */
+function entryState(file, link) {
+  let stat;
+  try {
+    stat = fs.lstatSync(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return "absent";
+    throw error;
+  }
+  if (!link || !stat.isSymbolicLink()) return "present";
+  const current = fs.readlinkSync(file);
+  return current === link.target || path.resolve(path.dirname(file), current) === link.dest ? "linked" : "present";
+}
+
+/** Resolve symlinks in the longest existing prefix of `p`; the missing remainder is kept as is. */
+function resolveExisting(p) {
+  const missing = [];
+  for (let current = p; ; current = path.dirname(current)) {
+    try {
+      return path.join(fs.realpathSync(current), ...missing.reverse());
+    } catch {
+      if (path.dirname(current) === current) return p;
+      missing.push(path.basename(current));
+    }
+  }
+}
+
+/** True when `base` is, or resolves to, the canonical directory (e.g. .claude/skills -> ../.agents/skills). */
+function sharesDirectory(base, canonicalBase) {
+  if (resolveExisting(base) === resolveExisting(canonicalBase)) return true;
+  try {
+    return path.resolve(path.dirname(base), fs.readlinkSync(base)) === canonicalBase;
+  } catch {
+    return false;
+  }
+}
+
+/** Inspect every destination before writing anything. */
+function plan(root) {
+  const canonicalBase = path.join(root, CANONICAL);
+  const conflicts = [];
+  const skills = SKILLS.map((name) => {
+    const dest = path.join(canonicalBase, name);
+    const replace = entryState(dest) !== "absent";
+    if (replace) conflicts.push(dest);
+    return { name, dest, replace };
+  });
+  const links = [];
+  for (const [harness, base] of Object.entries(LINKED)) {
+    const linkBase = path.join(root, base);
+    if (sharesDirectory(linkBase, canonicalBase)) {
+      links.push({ harness, base: linkBase, shared: true });
+      continue;
+    }
+    for (const { name, dest } of skills) {
+      const file = path.join(linkBase, name);
+      // Junctions (Windows) need absolute targets; elsewhere relative links survive moving the project.
+      const target = process.platform === "win32" ? dest : path.relative(linkBase, dest);
+      const state = entryState(file, { target, dest });
+      if (state === "present") conflicts.push(file);
+      links.push({ harness, base: linkBase, file, target, state });
+    }
+  }
+  return { canonicalBase, skills, links, conflicts };
+}
+
+function stage(staging) {
+  for (const name of SKILLS) {
+    fs.cpSync(path.join(SOURCE, name), path.join(staging, name), {
+      recursive: true,
+      filter: (src) => !EXCLUDED.includes(path.relative(SOURCE, src)),
+    });
+  }
+}
+
+/** Install the helper's locked dependencies without running package scripts. */
+function installDependencies(dir) {
+  const args = ["ci", "--ignore-scripts", "--no-audit", "--no-fund", "--loglevel=error"];
+  const npmCli = process.env.npm_execpath;
+  const [command, argv] = npmCli && /npm-cli\.c?js$/.test(npmCli) ? [process.execPath, [npmCli, ...args]] : ["npm", args];
+  const result = spawnSync(command, argv, { cwd: dir, stdio: ["ignore", "ignore", "inherit"], shell: command === "npm" && process.platform === "win32" });
+  if (result.error || result.status !== 0) {
+    throw new InstallError(`npm ci failed for the helper dependencies (${result.error?.message ?? `exit ${result.status}`})`, EXIT.PREREQUISITE);
+  }
+}
+
+/** Run the staged helper's own prerequisite check; returns its JSON report. */
+function setupCheck(dir) {
+  const result = spawnSync(process.execPath, [path.join(dir, "scripts", "validate-investigation.mjs"), "setup-check"], { encoding: "utf8" });
+  let body = null;
+  try {
+    body = JSON.parse(result.stdout);
+  } catch {
+    // Reported below with the exit status.
+  }
+  if (result.status !== 0 || body?.outcome !== "pass") {
+    throw new InstallError(`helper setup-check failed (exit ${result.status}): ${body?.error?.message ?? result.stderr.trim()}`, EXIT.PREREQUISITE);
+  }
+  return body;
+}
+
+/** Move staged skills into place; replaced entries stay aside until every move succeeded. */
+function swap(skills, staging) {
+  const aside = path.join(staging, ".replaced");
+  fs.mkdirSync(aside);
+  const moved = [];
+  try {
+    for (const skill of skills) {
+      if (skill.replace) fs.renameSync(skill.dest, path.join(aside, skill.name));
+      moved.push(skill);
+      fs.renameSync(path.join(staging, skill.name), skill.dest);
+    }
+  } catch (error) {
+    for (const skill of moved.reverse()) {
+      fs.rmSync(skill.dest, { recursive: true, force: true });
+      if (skill.replace) fs.renameSync(path.join(aside, skill.name), skill.dest);
+    }
+    throw new InstallError(`could not move the skills into place; previous entries restored (${error.message})`, EXIT.IO);
+  }
+}
+
+function link(links) {
+  for (const entry of links) {
+    if (entry.shared || entry.state === "linked") continue;
+    fs.mkdirSync(entry.base, { recursive: true });
+    if (entry.state === "present") fs.rmSync(entry.file, { recursive: true, force: true });
+    fs.symlinkSync(entry.target, entry.file, process.platform === "win32" ? "junction" : "dir");
+  }
+}
+
+/** The REA CLI the agents will find on PATH; it is a separate prerequisite, never installed here. */
+function reaVersion() {
+  const result = spawnSync("rea", ["--version"], { encoding: "utf8", shell: process.platform === "win32" });
+  return result.status === 0 ? result.stdout.trim().split(/\s+/).pop() : null;
+}
+
+function install(options) {
+  checkNode();
+  for (const name of SKILLS) {
+    if (!fs.existsSync(path.join(SOURCE, name, "SKILL.md"))) throw new InstallError(`incomplete package: ${name}/SKILL.md is missing`, EXIT.IO);
+  }
+  const root = path.resolve(options.dir);
+  if (!fs.statSync(root, { throwIfNoEntry: false })?.isDirectory()) throw new InstallError(`project directory not found: ${root}`, EXIT.USAGE);
+  const { canonicalBase, skills, links, conflicts } = plan(root);
+  if (conflicts.length && !options.force) {
+    throw new InstallError(`refusing to replace existing entries (rerun with --force to replace them):\n${conflicts.map((c) => `  ${c}`).join("\n")}`, EXIT.REFUSED);
+  }
+  fs.mkdirSync(canonicalBase, { recursive: true });
+  // Stage beside the real skills directory so the final moves are same-filesystem renames
+  // and an interrupted run never leaves a partial bundle where harnesses discover skills.
+  const staging = fs.mkdtempSync(path.join(path.dirname(fs.realpathSync(canonicalBase)), ".full-reverse-install-"));
+  try {
+    stage(staging);
+    installDependencies(path.join(staging, "full-reverse"));
+    const setup = setupCheck(path.join(staging, "full-reverse"));
+    swap(skills, staging);
+    link(links);
+    return { root, canonicalBase, links, setup };
+  } finally {
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+function report({ root, canonicalBase, links, setup }) {
+  const rel = (p) => path.relative(root, p) || ".";
+  const lines = [`full-reverse installed in ${root}`, `  skills: ${rel(canonicalBase)}/{${SKILLS.join(",")}}`];
+  for (const harness of Object.keys(LINKED)) {
+    const entries = links.filter((l) => l.harness === harness);
+    lines.push(
+      entries[0]?.shared
+        ? `  ${harness}: ${rel(entries[0].base)} already resolves to ${rel(canonicalBase)}; no links needed`
+        : `  ${harness}: ${rel(entries[0].base)}/<skill> -> ${entries[0].target.replace(SKILLS[0], "<skill>")}`,
+    );
+  }
+  lines.push(`  helper: setup-check ${setup.outcome} (Node.js ${setup.node}, ajv ${setup.ajv})`);
+  const rea = reaVersion();
+  lines.push(
+    rea
+      ? `  REA: ${rea} on PATH${rea === "6.4.0" ? "" : " (the skills target REA 6.4.0)"}`
+      : "  REA: not found on PATH; install it separately (npm package rea-agents; the skills target REA 6.4.0)",
+  );
+  lines.push(
+    "Notes:",
+    "  Pi loads project skills only after the project is trusted.",
+    `  ${rel(path.join(canonicalBase, "full-reverse", "node_modules"))} holds the helper dependencies; if version control ignores it, rerun with --force after cloning.`,
+  );
+  process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    process.stdout.write(`${USAGE}\n`);
+  } else if (options.command !== "install") {
+    throw new InstallError(options.command ? `unknown command: ${options.command}\n\n${USAGE}` : USAGE, EXIT.USAGE);
+  } else {
+    report(install(options));
+  }
+} catch (error) {
+  process.stderr.write(`full-reverse: ${error.message}\n`);
+  process.exitCode = error instanceof InstallError ? error.exit : EXIT.IO;
+}