fix(capture): keep URLs that WHATWG rejects instead of redacting userinfo

File URLs cannot carry userinfo (an "@" in a file host fails the parse),
and a special authority whose host or port WHATWG rejects fails the whole
URL. Neither has credentials, so the bridge now keeps their source text
and byte sidecar. Checked against Node's URL over 30,000 spellings: no
under-redaction, over-redaction 20,540 -> 5,865 (remaining: empty
userinfo, IPv4 range, IDNA, non-special and baseless references).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.agents/skills/reverse-engineer-anything/SKILL.md

@@ -2,7 +2,7 @@
 name: reverse-engineer-anything
 description: Reverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.
 metadata:
-  version: "42"
+  version: "41"
 ---
 
 # REA
@@ -104,10 +104,6 @@ explicit path or endpoint and do not need it.
   consult the NativeAOT workflow in `references/native-and-artifacts.md` for
   optional metadata recovery and its supported host/layout boundary.
 - User-owned browser page already open: `list_browser_targets`.
-- Browser action the agent must perform (click, type, navigate):
-  `capture_browser_scenario` with declared actions. See
-  [runtime observation](references/runtime-observation.md) for connect/launch
-  and the focused follow-up browser tools.
 - Fiddler Everywhere traffic or a native `.saz` capture: read the
   [Fiddler workflow](references/runtime-observation.md#fiddler-everywhere-traffic-debugging).
   Inspect saved SAZ with `inspect_web_network_capture` and `format: "saz"`;
@@ -327,8 +323,7 @@ as complete while required questions remain open.
   [references/javascript-applications.md](references/javascript-applications.md)
 - Android APK declarations, classes, methods, and static references:
   [references/android-applications.md](references/android-applications.md)
-- Browser/Electron observation (passive and scenario) and static/runtime
-  reconciliation:
+- Passive browser/Electron observation and static/runtime reconciliation:
   [references/runtime-observation.md](references/runtime-observation.md)
 - Evidence paging, comparisons, residual unknowns, and verification:
   [references/evidence-workflows.md](references/evidence-workflows.md)

.agents/skills/reverse-engineer-anything/references/runtime-observation.md

@@ -1,4 +1,4 @@
-# Browser and Electron runtime observation
+# Passive browser and Electron observation
 
 Supply the existing browser or Electron instance's literal-port loopback CDP
 endpoint in the request. No separate permission configuration or per-call
@@ -7,14 +7,13 @@ approval flag is needed. Browser discovery lists eligible HTTP(S) pages;
 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
+Start browser work with `list_browser_targets`; start Electron runtime work with
 `list_electron_targets`. 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.
+is passive: never claim REA clicked, navigated, evaluated page JavaScript,
+invoked IPC, captured prior activity, or contained 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
+Credentials, cookies, authorization headers, storage values, and raw
+WebSocket/JSON bodies are deliberately absent. 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
@@ -22,38 +21,6 @@ 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

bridge/mitmproxy/capture.py

@@ -11,6 +11,7 @@ import math
 import re
 import resource
 from pathlib import Path
+from urllib.parse import unquote_to_bytes
 
 from mitmproxy import ctx, version
 from mitmproxy.io import tnetstring
@@ -41,6 +42,113 @@ class BoundedReader:
         return self.handle.read(count)
 
 
+SPECIAL_SCHEMES = {"ftp", "file", "http", "https", "ws", "wss"}
+SCHEME_PREFIX = r"^[\x00-\x20]*([a-z][a-z0-9+.-]*):"
+NETWORK_PREFIX = r"^[\x00-\x20]*[/\\]{2}"
+URL_IGNORABLE_CONTROLS = "\t\n\r"
+URL_CONTROL_TRANSLATION = {ord(char): None for char in URL_IGNORABLE_CONTROLS}
+FORBIDDEN_DOMAIN_CODE_POINTS = {chr(code) for code in range(0x21)} | set("#%/:<>?@[\\]^|\x7f")
+
+
+def authority_start(text, base_scheme=None):
+    """Return where an authority begins and whether it is special, or None.
+
+    Follows WHATWG URL parsing as src/domain/recordedTransportUrl.ts does:
+    special schemes (and scheme-relative references) skip every leading "/"
+    or "\\" before the authority, so `https://\\user:pass@host` still has
+    userinfo. File URLs never carry userinfo: an "@" in a file host makes
+    WHATWG reject the whole URL, so there are no credentials to remove.
+    """
+    scheme = re.match(SCHEME_PREFIX, text, flags=re.I)
+    name = scheme.group(1).lower() if scheme is not None else None
+    if name == "file" or (name is None and base_scheme == "file"):
+        return None
+    if name is not None and name in SPECIAL_SCHEMES:
+        # A same-scheme Location without two slash-equivalent separators is
+        # relative to the recorded request, so its @ belongs to the path.
+        following = text[scheme.end():scheme.end() + 2]
+        if name == base_scheme and (len(following) < 2 or any(char not in "/\\" for char in following)):
+            return None
+        start = scheme.end()
+    else:
+        if scheme is not None:
+            if text[scheme.end():scheme.end() + 2] != "//":
+                return None
+            return scheme.end() + 2, False
+        # A non-special base treats backslashes as authority data and only
+        # recognizes two forward slashes as a network reference.
+        if base_scheme is not None and base_scheme not in SPECIAL_SCHEMES:
+            prefix = re.match(r"^[\x00-\x20]*//", text)
+            return None if prefix is None else (prefix.end(), False)
+        prefix = re.match(NETWORK_PREFIX, text)
+        if prefix is None:
+            return None
+        start = prefix.end()
+    while start < len(text) and text[start] in "/\\":
+        start += 1
+    return start, True
+
+
+def special_host_parses(host_port):
+    """Whether WHATWG could accept a special authority's host and port.
+
+    A rejected host fails the whole URL, so it has no credentials to remove.
+    This mirrors the forbidden-code-point, empty-host and port rules; IDNA,
+    IPv4 range and IPv6 syntax failures are not modeled and still redact.
+    """
+    if host_port.startswith("["):
+        host_end = host_port.find("]") + 1
+        if host_end == 0:
+            return False
+    else:
+        colon = host_port.find(":")
+        host_end = len(host_port) if colon < 0 else colon
+        host = unquote_to_bytes(host_port[:host_end]).decode("utf-8", errors="replace")
+        if host == "" or any(char in FORBIDDEN_DOMAIN_CODE_POINTS for char in host):
+            return False
+    port = host_port[host_end:]
+    if port == "":
+        return True
+    digits = port[1:]
+    return port[0] == ":" and (digits == "" or (digits.isascii() and digits.isdigit() and int(digits) <= 65535))
+
+
+def without_userinfo(value, base_scheme=None):
+    """Remove an authority's userinfo using the WHATWG authority boundary.
+
+    Special schemes and scheme-relative references also end the authority
+    at a backslash, so later path text containing "@" is not userinfo.
+    """
+    binary = isinstance(value, bytes)
+    text = value.decode("latin-1") if binary else value
+    # WHATWG removes these controls before interpreting scheme/separators.
+    # Keep that parse view separate from the exact source spelling and bytes.
+    parsed_text = text.translate(URL_CONTROL_TRANSLATION)
+    located = authority_start(parsed_text, base_scheme)
+    if located is None:
+        return value
+    start, special = located
+    terminators = "/?#\\" if special else "/?#"
+    end = start
+    while end < len(parsed_text) and parsed_text[end] not in terminators:
+        end += 1
+    at = parsed_text.rfind("@", start, end)
+    if at < start or (special and not special_host_parses(parsed_text[at + 1 : end])):
+        return value
+    parsed_offset = 0
+    raw_start = 0
+    for raw_offset, char in enumerate(text):
+        if char in URL_IGNORABLE_CONTROLS:
+            continue
+        if parsed_offset == start:
+            raw_start = raw_offset
+        if parsed_offset == at:
+            safe = text[:raw_start] + text[raw_offset + 1 :]
+            return safe.encode("latin-1") if binary else safe
+        parsed_offset += 1
+    raise CaptureFailure("decoder", "Normalized URL authority could not be bound to its source.")
+
+
 def project_record(state, secrets):
     binaries, numbers, redactions = [], [], []
     byte_secrets = []
@@ -58,16 +166,23 @@ def project_record(state, secrets):
             return None
         return text
 
-    def transport_value(value, path, transport_url):
+    def transport_value(value, path, transport_url, base_scheme):
         if not (transport_url or re.fullmatch(r"/(?:backup/)*request/(?:path|authority)", path)):
             return value, False
         binary = isinstance(value, bytes)
-        pattern = rb"^([\x00-\x20]*(?:[a-z][a-z0-9+.-]*:)?//)[^/?#]*@" if binary else r"^([\x00-\x20]*(?:[a-z][a-z0-9+.-]*:)?//)[^/?#]*@"
-        replacement = rb"\1" if binary else r"\1"
         separator = b"@" if binary else "@"
-        safe_url = re.sub(pattern, replacement, value, flags=re.I)
-        if path.endswith("/authority") and separator in safe_url:
-            safe_url = safe_url.rsplit(separator, 1)[1]
+        if transport_url:
+            safe_url = without_userinfo(value, base_scheme)
+        elif path.endswith("/authority"):
+            safe_url = value.rsplit(separator, 1)[-1]
+        else:
+            # Native request.path is origin-form unless it explicitly carries
+            # a scheme (absolute-form). Leading separators are path evidence,
+            # not a header URL reference's network authority.
+            text = value.decode("latin-1") if binary else value
+            safe_url = without_userinfo(value) if re.match(
+                SCHEME_PREFIX, text.translate(URL_CONTROL_TRANSLATION), flags=re.I
+            ) else value
         changed = safe_url != value
         if changed:
             redactions.append({"pointer": path, "reason": "transport-credential"})
@@ -80,7 +195,7 @@ def project_record(state, secrets):
         del numbers[before[1]:]
         del redactions[before[2]:]
 
-    def visit(value, path, depth=0, credential=False, transport_url=False):
+    def visit(value, path, depth=0, credential=False, transport_url=False, base_scheme=None):
         if depth > 64:
             raise CaptureFailure("input-limit", "Native capture exceeds the 64-level evidence nesting budget.", path)
         if credential:
@@ -90,7 +205,7 @@ def project_record(state, secrets):
                 binaries.append({"pointer": path, "representation": "producer-bytes", "state": "redacted", "content_base64": None, "bytes": None, "sha256": None})
             return None
         if isinstance(value, bytes):
-            safe_bytes, credential_url = transport_value(value, path, transport_url)
+            safe_bytes, credential_url = transport_value(value, path, transport_url, base_scheme)
             content_base64 = base64.b64encode(value).decode("ascii")
             digest = hashlib.sha256(value).hexdigest()
             hidden = any(secret in value or secret in safe_bytes for secret in byte_secrets) or any(secret in content_base64 or secret in digest or secret in str(len(value)) for secret in secrets)
@@ -107,7 +222,7 @@ def project_record(state, secrets):
                 return None
             return safe_text
         if isinstance(value, str):
-            safe_text, _ = transport_value(value, path, transport_url)
+            safe_text, _ = transport_value(value, path, transport_url, base_scheme)
             return redact(safe_text, path, value)
         if isinstance(value, bool) or value is None:
             return value
@@ -125,10 +240,16 @@ def project_record(state, secrets):
                 for index, field in enumerate(value):
                     if not isinstance(field, (list, tuple)) or len(field) != 2 or not isinstance(field[0], bytes):
                         raise CaptureFailure("format", "Native header/trailer is not an ordered byte pair.", pointer(path, index))
-                    result.append([visit(field[0], pointer(pointer(path, index), 0), depth + 2), visit(field[1], pointer(pointer(path, index), 1), depth + 2, field[0].lower() in CREDENTIALS, field[0].lower() in {b"location", b"referer", b"origin"})])
+                    result.append([visit(field[0], pointer(pointer(path, index), 0), depth + 2), visit(field[1], pointer(pointer(path, index), 1), depth + 2, field[0].lower() in CREDENTIALS, field[0].lower() in {b"location", b"referer", b"origin"}, base_scheme if field[0].lower() == b"location" else None)])
                 return result
-            return [visit(item, pointer(path, index), depth + 1) for index, item in enumerate(value)]
+            return [visit(item, pointer(path, index), depth + 1, base_scheme=base_scheme) for index, item in enumerate(value)]
         if isinstance(value, dict):
+            if path == "" or re.fullmatch(r"/backup(?:/backup)*", path):
+                request = value.get("request")
+                scheme = request.get("scheme") if isinstance(request, dict) else None
+                if isinstance(scheme, bytes):
+                    scheme = scheme.decode("latin-1")
+                base_scheme = scheme.lower() if isinstance(scheme, str) and re.fullmatch(r"[a-z][a-z0-9+.-]*", scheme, flags=re.I) else None
             result = {}
             for key, item in value.items():
                 if not isinstance(key, str):
@@ -139,7 +260,7 @@ def project_record(state, secrets):
                     validate_omitted(item, pointer(path, key), depth + 1)
                     redactions.append({"pointer": path, "reason": "explicit-sensitive-value", "scope": "property-name"})
                     continue
-                result[key] = visit(item, pointer(path, key), depth + 1)
+                result[key] = visit(item, pointer(path, key), depth + 1, base_scheme=base_scheme)
             return result
         raise CaptureFailure("decoder", "Native parser returned an unexpected value type: " + type(value).__name__ + ".", path)
 

bridge/mitmproxy/test_capture.py

@@ -0,0 +1,214 @@
+"""Source-owned tests for the mitmproxy adapter's record projection."""
+
+import importlib.util
+import os
+import sys
+import types
+import unittest
+from unittest import mock
+
+
+def load_capture():
+    """Load the adapter with fresh mitmproxy stand-ins scoped to its import."""
+    fake_mitmproxy = types.ModuleType("mitmproxy")
+    fake_mitmproxy.ctx = types.SimpleNamespace()
+    fake_mitmproxy.version = types.SimpleNamespace(VERSION="12.2.3")
+    fake_io = types.ModuleType("mitmproxy.io")
+    fake_io.tnetstring = types.ModuleType("mitmproxy.io.tnetstring")
+    stand_ins = {
+        "mitmproxy": fake_mitmproxy,
+        "mitmproxy.io": fake_io,
+        "mitmproxy.io.tnetstring": fake_io.tnetstring,
+    }
+    spec = importlib.util.spec_from_file_location(
+        "rea_mitmproxy_capture", os.path.join(os.path.dirname(__file__), "capture.py")
+    )
+    module = importlib.util.module_from_spec(spec)
+    with mock.patch.dict(sys.modules, stand_ins):
+        spec.loader.exec_module(module)
+    return module
+
+
+capture = load_capture()
+
+
+def location(value, scheme=None):
+    state = {"response": {"headers": [[b"Location", value]]}}
+    if scheme is not None:
+        state["request"] = {"scheme": scheme}
+    record = capture.project_record(state, [])
+    sidecar = next(
+        field for field in record["binary_fields"] if field["pointer"] == "/response/headers/0/1"
+    )
+    return record["reported"]["response"]["headers"][0][1], sidecar, record["redactions"]
+
+
+class TransportUserinfoTests(unittest.TestCase):
+    def test_ignorable_controls_cannot_hide_authority_credentials(self):
+        for control in [b"\t", b"\n", b"\r"]:
+            for value in [b"https://" + control + b"/user:pass@host/path", b"ht" + control + b"tps://user:" + control + b"pass@host/path"]:
+                with self.subTest(value=value):
+                    text, sidecar, redactions = location(value, b"https")
+                    self.assertNotIn("user", text)
+                    self.assertNotIn("pass", text)
+                    self.assertEqual(sidecar["state"], "redacted")
+                    self.assertEqual(len(redactions), 1)
+
+    def test_mixed_network_separators_remove_credentials(self):
+        for prefix in [b"\\\\", b"/\\", b"\\/"]:
+            with self.subTest(prefix=prefix):
+                text, sidecar, redactions = location(prefix + b"user:pass@host/path", b"https")
+                self.assertEqual(text, prefix.decode("ascii") + "host/path")
+                self.assertEqual(sidecar["state"], "redacted")
+                self.assertEqual(len(redactions), 1)
+
+    def test_non_special_base_keeps_backslashes_inside_network_authorities(self):
+        text, sidecar, redactions = location(b"//user\\name:pass@host/x", b"foo")
+        self.assertEqual(text, "//host/x")
+        self.assertEqual(sidecar["state"], "redacted")
+        self.assertEqual(len(redactions), 1)
+        text, sidecar, redactions = location(b"/\\invoice@customer", b"foo")
+        self.assertEqual(text, "/\\invoice@customer")
+        self.assertEqual(sidecar["state"], "retained")
+        self.assertEqual(redactions, [])
+
+    def test_native_request_paths_preserve_origin_form_and_redact_absolute_form(self):
+        for value in [b"/\\invoice@customer", b"//invoice@customer", b"\\\\invoice@customer"]:
+            with self.subTest(value=value):
+                record = capture.project_record({"request": {"path": value}}, [])
+                self.assertEqual(record["reported"]["request"]["path"], value.decode("ascii"))
+                self.assertEqual(record["binary_fields"][0]["state"], "retained")
+                self.assertEqual(record["redactions"], [])
+        record = capture.project_record({"request": {"path": b"https://user:pass@host/x"}}, [])
+        self.assertEqual(record["reported"]["request"]["path"], "https://host/x")
+        self.assertEqual(record["binary_fields"][0]["state"], "redacted")
+
+    def test_same_scheme_locations_preserve_relative_path_text_and_bytes(self):
+        for value in [b"https:invoice@customer", b"https:/invoice@customer", b"https:\\invoice@customer"]:
+            with self.subTest(value=value):
+                text, sidecar, redactions = location(value, b"https")
+                self.assertEqual(text, value.decode("ascii"))
+                self.assertEqual(sidecar["state"], "retained")
+                self.assertEqual(redactions, [])
+
+    def test_location_authorities_still_remove_credentials_with_a_base_scheme(self):
+        for value, scheme, expected in [
+            (b"https://user:pass@host/path", b"https", "https://host/path"),
+            (b"https:\\\\user:pass@host/path", b"https", "https:\\\\host/path"),
+            (b"https:user:pass@host/path", b"http", "https:host/path"),
+        ]:
+            with self.subTest(value=value, scheme=scheme):
+                text, sidecar, redactions = location(value, scheme)
+                self.assertEqual(text, expected)
+                self.assertEqual(sidecar["state"], "redacted")
+                self.assertEqual(len(redactions), 1)
+
+    def test_backup_location_uses_its_own_request_scheme(self):
+        record = capture.project_record({
+            "request": {"scheme": b"http"},
+            "backup": {
+                "request": {"scheme": b"https"},
+                "response": {"headers": [[b"Location", b"https:invoice@customer"]]},
+            },
+        }, [])
+        self.assertEqual(record["reported"]["backup"]["response"]["headers"][0][1], "https:invoice@customer")
+        self.assertEqual(record["redactions"], [])
+
+    def test_backslash_ends_a_special_scheme_authority(self):
+        text, sidecar, redactions = location(b"https://example.test\\part@tail")
+        self.assertEqual(text, "https://example.test\\part@tail")
+        self.assertEqual(sidecar["state"], "retained")
+        self.assertIsNotNone(sidecar["content_base64"])
+        self.assertEqual(redactions, [])
+
+    def test_userinfo_before_a_backslash_is_still_removed(self):
+        text, sidecar, redactions = location(b"https://user:pw@example.test\\path")
+        self.assertEqual(text, "https://example.test\\path")
+        self.assertEqual(sidecar["state"], "redacted")
+        self.assertEqual(
+            redactions,
+            [{"pointer": "/response/headers/0/1", "reason": "transport-credential"}],
+        )
+
+    def test_ordinary_userinfo_is_removed(self):
+        text, _sidecar, _redactions = location(b"https://user:pw@example.test/a@b")
+        self.assertEqual(text, "https://example.test/a@b")
+
+    def test_empty_userinfo_marker_is_removed(self):
+        self.assertEqual(
+            capture.without_userinfo("https://@host"), "https://host"
+        )
+
+    def test_special_schemes_skip_leading_slashes_before_userinfo(self):
+        for value, expected in [
+            (b"https://\\user:pass@host/path", b"https://\\host/path"),
+            (b"https:\\\\user:pass@host/path", b"https:\\\\host/path"),
+            (b"https:user:pass@host", b"https:host"),
+            (b"//\\user:pass@host", b"//\\host"),
+        ]:
+            with self.subTest(value=value):
+                self.assertEqual(capture.without_userinfo(value), expected)
+        text, sidecar, redactions = location(b"https://\\user:pass@host/path")
+        self.assertEqual(text, "https://\\host/path")
+        self.assertEqual(sidecar["state"], "redacted")
+        self.assertEqual(len(redactions), 1)
+
+    def test_file_base_keeps_paths_after_the_fixed_network_boundary(self):
+        for value in [b"///u@h", b"////u@h"]:
+            with self.subTest(value=value):
+                text, sidecar, redactions = location(value, b"file")
+                self.assertEqual(text, value.decode("ascii"))
+                self.assertEqual(sidecar["state"], "retained")
+                self.assertIsNotNone(sidecar["content_base64"])
+                self.assertEqual(redactions, [])
+
+    def test_file_urls_keep_path_text(self):
+        self.assertEqual(capture.without_userinfo("file:///a@b"), "file:///a@b")
+
+    def test_file_urls_reject_userinfo_and_keep_their_source(self):
+        # WHATWG rejects an "@" in a file host, so nothing parses as credentials.
+        self.assertEqual(
+            capture.without_userinfo("file://user:pass@host/x"), "file://user:pass@host/x"
+        )
+        for value in [b"\\\\user:pass@host/x", b"/\\user:pass@host/x", b"//user:pass@host/x"]:
+            with self.subTest(value=value):
+                text, sidecar, redactions = location(value, b"file")
+                self.assertEqual(text, value.decode("ascii"))
+                self.assertEqual(sidecar["state"], "retained")
+                self.assertEqual(redactions, [])
+
+    def test_rejected_special_hosts_keep_their_source(self):
+        # A rejected host or port fails the whole URL, so it has no userinfo.
+        for value in [
+            "https:user@%",
+            "https://user@",
+            "https://user:pass@h^st/x",
+            "https://user@ho st/x",
+            "https://user@host:99999/x",
+            "https://user@host:12a",
+            "https://user@[::1",
+        ]:
+            with self.subTest(value=value):
+                self.assertEqual(capture.without_userinfo(value), value)
+        text, sidecar, redactions = location(b"https://user:pass@h^st/x", b"https")
+        self.assertEqual(text, "https://user:pass@h^st/x")
+        self.assertEqual(sidecar["state"], "retained")
+        self.assertEqual(redactions, [])
+
+    def test_accepted_special_hosts_still_remove_userinfo(self):
+        for value, expected in [
+            ("https:user@%41", "https:%41"),
+            ("https://user@[::1]:8443/x", "https://[::1]:8443/x"),
+            ("https://user@host:/x", "https://host:/x"),
+            ("wss://user:pass@host:65535", "wss://host:65535"),
+        ]:
+            with self.subTest(value=value):
+                self.assertEqual(capture.without_userinfo(value), expected)
+
+    def test_non_special_schemes_keep_backslashes_in_the_authority(self):
+        self.assertEqual(capture.without_userinfo("foo://a\\b@host/x"), "foo://host/x")
+        self.assertEqual(capture.without_userinfo(b"//a\\b@host"), b"//a\\b@host")
+
+
+if __name__ == "__main__":
+    unittest.main()

docs/client-configuration.md

@@ -294,11 +294,7 @@ the first native server into an empty table, it copies the fallback's
 `mcpServers` entries into the native table so they keep loading, and leaves
 the fallback file untouched. Existing REA environment overrides are preserved
 when refreshing its command. A malformed or unreadable fallback file fails setup instead of
-being silently suppressed; repair or remove it and rerun. Uninstall removes an
-REA-owned `rea` entry from both the native table and the fallback, backing up
-each changed file, so an emptied native table cannot load a leftover fallback
-registration; other fallback servers, settings and a foreign `rea` entry are
-kept. ZCode disables a
+being silently suppressed; repair or remove it and rerun. ZCode disables a
 server with `enable: false` on its entry; doctor reports such a registration
 as stale, and rerunning setup removes the flag to repair it. Native configuration
 uses strict JSON; setup refuses comments, trailing commas and a BOM rather than

docs/installation.md

@@ -129,150 +129,6 @@ Setup pins package-runner MCP registrations to the exact installed REA version,
 installs the matching skill and on-demand references in the same plan, and adds
 `startup_timeout_sec = 30` for Codex and Grok Build.
 
-## Limit REA to one project or agent profile
-
-Setup registers REA for the whole client. For Claude Code it writes
-`mcpServers.rea` in `~/.claude.json` and installs the bundled skill under
-`~/.claude/skills`, so every project that Claude Code opens can call REA. To
-offer REA's tools only where they're wanted, use one of the routes below.
-
-Both routes control which sessions discover REA's MCP server and skill. They
-leave shell commands, filesystem access and network access available. An agent
-under the same OS account can run `rea` from `PATH` or `npx` and read other
-profiles and REA output. For clean-room separation, use an implementation
-environment with filesystem and network restrictions that prevent reading or
-fetching REA, the target and analysis output, including through shared
-installations and package registries. A separate account or container must
-enforce those restrictions.
-
-For Claude Code, check existing default-profile state before choosing either
-route. Setup is additive: a previous user-level REA registration and personal
-skill remain active in other projects. Back up the default configuration and
-REA skill first, then, with `CLAUDE_CONFIG_DIR` unset, remove the REA user
-registration with `claude mcp remove --scope user rea` and remove the known
-REA-installed `~/.claude/skills/reverse-engineer-anything` directory. Preserve
-unrelated registrations and skills. `rea uninstall` applies to other clients
-as well, so it is broader than this Claude-only migration.
-
-**A separate Claude Code profile.** Claude Code keeps settings, skills and session
-history under `CLAUDE_CONFIG_DIR`. Setup follows the same
-variable: it writes the registration to `$CLAUDE_CONFIG_DIR/.claude.json` and
-the skill to `$CLAUDE_CONFIG_DIR/skills`.
-
-```bash
-CLAUDE_CONFIG_DIR=~/.claude-rea npx rea-agents setup --client claude_code
-CLAUDE_CONFIG_DIR=~/.claude-rea claude
-```
-
-A new profile may need authentication. Console sign-ins without an API key are
-stored outside `CLAUDE_CONFIG_DIR`; see
-[Claude Code authentication](https://code.claude.com/docs/en/authentication#log-in-with-multiple-accounts).
-Sessions started without the variable use the default profile's registration,
-skill and history.
-
-Inline assignments apply only to that command. Keep the same prefix for every
-profile check, setup rerun, update, or removal; bare commands use the current
-environment and can otherwise inspect or recreate default-profile state:
-
-```bash
-CLAUDE_CONFIG_DIR=~/.claude-rea claude mcp list
-CLAUDE_CONFIG_DIR=~/.claude-rea npx rea-agents doctor --client claude_code --skill --json
-CLAUDE_CONFIG_DIR=~/.claude-rea npx -y rea-agents@latest setup --client claude_code --dry-run
-```
-
-After reviewing an update plan, rerun that same prefixed setup command without
-`--dry-run` and approve its exact changes. Profile removal likewise needs the
-prefix on `claude mcp remove --scope user rea` and any `rea uninstall` command;
-keep the broader client scope of uninstall in mind. Restart the selected
-profile after changing its pinned registration.
-
-`claude mcp remove` removes only the registration. To remove REA from this
-profile without running the broader uninstall flow, first back up the profile's
-REA-managed skill directory, then remove
-`$CLAUDE_CONFIG_DIR/skills/reverse-engineer-anything` as well. Keep other skills
-in the profile intact.
-
-The commands above use POSIX shell assignment syntax. In native Windows
-PowerShell, select the profile for the whole setup/launch/check session and
-restore the previous selection afterward:
-
-```powershell
-$previousClaudeConfigDir = $env:CLAUDE_CONFIG_DIR
-try {
-  $env:CLAUDE_CONFIG_DIR = Join-Path $HOME ".claude-rea"
-  npx rea-agents setup --client claude_code
-  claude mcp list
-  npx rea-agents doctor --client claude_code --skill --json
-  npx -y rea-agents@latest setup --client claude_code --dry-run
-  # After reviewing the plan, repeat setup without --dry-run and approve it.
-  claude
-  # Profile removal, when intended, also belongs inside this selected scope:
-  # claude mcp remove --scope user rea
-} finally {
-  if ($null -eq $previousClaudeConfigDir) {
-    Remove-Item Env:CLAUDE_CONFIG_DIR -ErrorAction SilentlyContinue
-  } else {
-    $env:CLAUDE_CONFIG_DIR = $previousClaudeConfigDir
-  }
-}
-```
-
-Use PowerShell for these Windows examples rather than pasting POSIX assignments
-into cmd.exe. Keep profile updates, readiness checks and removal inside the
-same selected environment; the `finally` block restores the previous profile
-or unsets the variable when it was absent.
-
-**One project.** Install without configuring Claude Code: use the curl
-installer's `--no-setup`, or run setup only for other clients. Then register
-REA from the project directory at Claude Code's local scope.
-
-This route uses the default Claude profile. Keep `CLAUDE_CONFIG_DIR` unset for
-the entire local lifecycle: registration, backup, listing, version replacement
-and removal. In POSIX shells run `unset CLAUDE_CONFIG_DIR`; in PowerShell run
-`Remove-Item Env:CLAUDE_CONFIG_DIR -ErrorAction SilentlyContinue` before these
-commands. Record an existing selection first if you intend to restore it after
-finishing. The configuration path below is the default profile's
-`~/.claude.json`; a different active profile uses its own config root instead.
-
-Register with the variable unset:
-
-<!-- x-release-please-start-version -->
-
-```bash
-claude mcp add --scope local rea -- npx -y rea-agents@6.4.0 mcp
-```
-
-On native Windows, use the same project directory and wrap the package-runner
-shim so the stdio client can launch it:
-
-```powershell
-claude mcp add --scope local rea -- cmd.exe /d /c npx -y rea-agents@6.4.0 mcp
-```
-
-<!-- x-release-please-end -->
-
-Local scope stores the entry under that directory's path in `~/.claude.json`,
-so other projects don't load it. This route doesn't install the bundled skill.
-Avoid `--scope project`, which writes `.mcp.json` into the repository where it
-can be committed or copied. `rea doctor` and `rea uninstall` read only the
-user-level entry, so they don't report or remove a local-scope registration;
-remove it with `claude mcp remove --scope local rea` from the same directory.
-`rea update` doesn't refresh it either, so it stays on the version it names.
-To move it to a newer release, first back up the project entry in
-`~/.claude.json` and record its environment and other metadata. In particular,
-preserve caller-selected overrides such as `REA_MCP_INPUT_SCHEMA_PROFILE` and
-`REA_MCP_MAX_RESPONSE_BYTES`. Run `claude mcp remove --scope local rea` from the
-same directory, then recreate it with the platform-appropriate command above
-and the new version. Reapply every recorded environment value with Claude
-Code's `mcp add --env NAME=value` options and restore any other retained entry
-metadata before restarting the project session. Removal and re-addition do not
-preserve these values automatically. Running setup for Claude Code instead
-would add a user-level entry for every project.
-
-Check the separate profile with the prefixed `claude mcp list` above and compare
-with the default profile with `CLAUDE_CONFIG_DIR` unset. For local scope, run
-`claude mcp list` from the selected project and again from another project.
-
 ## Check readiness for your task
 
 Run `rea doctor` when you need diagnosis. It reads host prerequisites and agent

docs/readme/README_ko.md

@@ -20,7 +20,7 @@
 
 **[웹사이트](https://rea.tools/ko/) · [가이드](https://rea.tools/ko/guides/) · [사례](https://rea.tools/ko/showcase/)**
 
-[빠른 시작](#빠른-시작) · [REA의 작동 방식](#rea의-작동-방식) · [분석할 수 있는 대상](#분석할-수-있는-대상) · [사례](#사례) · [자주 묻는 질문](#자주-묻는-질문) · [문서](#문서)
+[빠른 시작](#빠른-시작) · [REA의 작동 방식](#rea의-작동-방식) · [분석할 수 있는 대상](#분석할-수-있는-대상) · [사례](#사례) · [자주 묻는 질문](#자주-묻는-질문) · [GNU objdump 및 Rizin 도구](../reverse-engineering-tools.md) · [문서](#문서)
 
 <code>npx rea-agents setup</code>
 
@@ -56,7 +56,7 @@
 
 REA는 에이전트를 분석 도구에 연결해 네이티브 바이너리, JavaScript와 Electron 앱, .NET 어셈블리, 웹사이트를 검사할 수 있게 합니다. 터미널에서도 같은 도구를 사용할 수 있습니다. 분석은 로컬에서 실행되며, 결과에는 각 결론의 근거와 한계가 포함됩니다.
 
-설정 과정은 에이전트에 REA를 등록하고 해당 버전에 맞는 워크플로 지침을 설치합니다. 네이티브 분석에는 기존 Hopper, Ghidra 또는 IDA 설치를 사용할 수 있습니다. 승인하면 설정 과정에서 Hopper를 설치할 수도 있습니다. 정적 JavaScript 분석에는 네이티브 분석 엔진이 필요하지 않습니다.
+설정 과정은 에이전트에 REA를 등록하고 해당 버전에 맞는 워크플로 지침을 설치합니다. 네이티브 분석에는 기존 Hopper 또는 Ghidra 설치를 사용할 수 있습니다. 승인하면 설정 과정에서 Hopper를 설치할 수도 있습니다. 정적 JavaScript 분석에는 두 엔진 모두 필요하지 않습니다.
 
 > **[REA 웹사이트](https://rea.tools/ko/)**에서 설정 방법, 그림으로 설명한 가이드, 실제 사례를 확인하세요.
 
@@ -105,14 +105,12 @@ rea --help
 
 REA는 빠르게 바뀌며 새 릴리스에는 버그 수정이 자주 포함됩니다. 설치된 버전을 최신으로 유지하세요.
 
-`npm install --global` 또는 `bun add --global`로 설치한 CLI에서는 다음 명령을 사용합니다.
+npm으로 설치한 CLI에서는 다음 명령을 사용합니다.
 
 ```bash
 rea update
 ```
 
-Bun 전역 업데이트에는 Bun 1.2.17 이상이 필요합니다. 이전 버전의 Bun을 사용한다면 `rea update`를 실행하기 전에 Bun을 직접 업그레이드하세요.
-
 에이전트 등록과 스킬을 갱신하려면 업데이트 과정에서 출력된 설정 명령을 실행하세요.
 
 `npx`를 사용한다면 다음 명령으로 에이전트 설정을 갱신하세요.
@@ -121,7 +119,7 @@ Bun 전역 업데이트에는 Bun 1.2.17 이상이 필요합니다. 이전 버
 npx rea-agents@latest setup
 ```
 
-설정 변경 사항을 검토하고 에이전트를 다시 시작하세요. 일회성 CLI 작업에는 `npx rea-agents@latest` 뒤에 필요한 명령을 붙여 실행하세요. Bun을 사용한다면 위 명령의 `npx rea-agents@latest`를 `bunx rea-agents@latest`로 바꿔 실행하세요.
+설정 변경 사항을 검토하고 에이전트를 다시 시작하세요. 일회성 CLI 작업에는 `npx rea-agents@latest` 뒤에 필요한 명령을 붙여 실행하세요.
 
 ## REA의 작동 방식
 
@@ -141,16 +139,14 @@ REA에는 Node.js 22.x(>=22.19), 24.x(>=24.11) 또는 26+와 npm이 필요합니
 | --------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | 네이티브 바이너리     | 의사 코드, 어셈블리, 문자열, 심볼, 호출, 참조                                 | Hopper, Ghidra 또는 IDA; [네이티브 분석](https://rea.tools/ko/guides/native/)                                                     |
 | 오프라인 ELF 레이아웃 | 섹션, 세그먼트, 원본 심볼/재배치 정보, 정적 분석으로 얻은 보안 완화 기법 후보 | Linux x64에서 호출자가 제공하는 pwntools; [바이너리 진단](../binary-diagnostics.md)                                               |
-| Go 바이너리           | 내장된 컴파일러 버전, 모듈, `replace` 지시어, 빌드 설정                       | REA 내장 ELF/PE/thin Mach-O 정적 검사; Go 설치 불필요                                                                             |
-| Rust 바이너리         | cargo-auditable이 내장한 크레이트 이름, 버전, 소스, 의존성 관계               | REA 내장 ELF/PE/thin Mach-O 정적 검사; [Rust 바이너리](../rust-binaries.md)                                                       |
-| WASM 아티팩트         | 유효성 검사, 섹션, import/export의 정확한 WAT 형식, 디코딩된 WAT              | 호출자 제공 WABT 1.0.42; `inspect_wasm_artifact`                                                                                  |
 | EVM 바이트코드        | 디스패치 선택자, 바이트 오프셋, 추론한 인자와 상태 변경 가능 여부             | Linux x64의 로컬 원시 바이트/16진수 입력 파일; [오프라인 EVM 가이드](../evm-bytecode.md)                                          |
-| SQLite 데이터베이스   | 테이블, 열, 인덱스, 뷰, 트리거, 선택한 일반 테이블의 행                       | 로컬 데이터베이스/WAL 스냅샷; Node.js 24.15 이상의 24.x 또는 26 이상(네이티브 SQLite 한도 적용)                                   |
+| Rust binaries         | Embedded cargo-auditable dependency list                                      | [Rust binaries](../rust-binaries.md)                                                                                              |
 | 기록된 Linux 크래시   | 원시 note 레코드, 기록된 모든 스레드의 레지스터/시그널, 선택적 매핑 후보      | Linux x64에서 호출자가 제공하는 pwntools; GDB/pwndbg는 선택 사항; [기록된 크래시](../recorded-crashes.md)                         |
 | JavaScript / Electron | 모듈, 임포트, 소스 맵, 라우트, IPC, 네이티브 애드온 관계                      | Node.js와 npm; [애플리케이션 분석](https://rea.tools/ko/guides/javascript/)                                                       |
 | 웹사이트              | 페이지 구조, 스크립트, 네트워크 관찰 결과, 요청한 스크린샷                    | Chrome 계열 브라우저; [브라우저 분석](https://rea.tools/ko/guides/browser/)                                                       |
-| 저장된 네트워크 캡처  | 요청, 응답, 접근 가능한 페이로드, 소스 위치                                   | HAR 또는 Fiddler Everywhere SAZ; mitmproxy 네이티브 캡처에는 Linux의 mitmdump; [캡처 가이드](../web-network-captures.md)          |
-| .NET 어셈블리         | 메타데이터, CIL 명령, 선언된 네이티브 의존성, 빌드 비교                       | 별도 도구 불필요(정적 검사만); [관리 코드 가이드](../managed-code-analysis.md)                                                    |
+| 저장된 네트워크 캡처  | 요청, 응답, 접근 가능한 페이로드, 소스 위치                                   | HAR; mitmproxy 네이티브 캡처에는 Linux의 mitmdump; [캡처 가이드](../web-network-captures.md)                                      |
+| 패킷 캡처             | 엔드포인트, DNS, TLS SNI, 프로토콜 분포, HTTP 요청                            | 호출자 제공 tshark 및 capinfos; [pcap 가이드](../pcap-analysis.md)                                                                |
+| .NET 어셈블리         | 메타데이터, CIL 명령, 선언된 네이티브 의존성, 빌드 비교                       | 정적 검사; [관리 코드 가이드](../managed-code-analysis.md)                                                                        |
 | Android APK           | 매니페스트 선언, 클래스, 디컴파일된 메서드, 참조                              | Linux/macOS/Windows x64의 헤드리스 JADX와 전체 JDK; [Android 가이드](../android-analysis.md)                                      |
 | Android 기기          | 기기, 패키지, 프로세스, 로그, 덤프, 화면 캡처, APK/파일 전송                  | 호출자 제공 adb(에뮬레이터 또는 실제 기기); [ADB 가이드](../adb-device-analysis.md)                                               |
 | JEB 프로젝트          | 엔진 기반 프로젝트 유닛, 아티팩트 해시, 타입/메서드 의사코드                  | 호출자가 시작하고 MCP를 제공하는 JEB 클라이언트(REA_JEB_MCP_URL로 선택); [JEB 가이드](../jeb-analysis.md)                         |
@@ -158,18 +154,15 @@ REA에는 Node.js 22.x(>=22.19), 24.x(>=24.11) 또는 26+와 npm이 필요합니
 | Flutter 앱            | Dart 스냅샷 해시, ABI별 라이브러리 해시, 엔진 빌드 출처                       | 없음 (정적 APK 파싱); [Flutter 가이드](../flutter-analysis.md)                                                                    |
 | 펌웨어                | 영역, 추출 결과, 네이티브 분석으로 전달할 정보                                | Linux의 Binwalk / Unblob; [펌웨어 가이드](../firmware-analysis.md)                                                                |
 | 기록된 패킷           | 선택 필드, 반복 값, 필터 및 디코딩 규칙                                       | Linux: TShark 4.x + prlimit; [캡처 가이드](../packet-captures.md)                                                                 |
-| 패킷 요약             | 엔드포인트, DNS, TLS SNI, 프로토콜 분포, HTTP 요청                            | 호출자 제공 tshark 및 capinfos(Linux에서 검증됨); [pcap 가이드](../pcap-analysis.md)                                              |
 | 기록된 논리 신호      | 디코더 주석, 샘플 범위, 진단 정보                                             | Linux: sigrok-cli 0.7.2 + prlimit; [신호 기록 가이드](../signal-recordings.md)                                                    |
 | 패키지 및 리소스      | 파일 목록, 다이제스트, plist, Apple 번들 구조, 추출한 리소스                  | [아티팩트 및 JavaScript 가이드](../javascript-artifact-reconstruction.md), [Apple 애플리케이션](../apple-application-analysis.md) |
 | 프로세스 동작         | 터미널 출력, 상호작용, 종료 및 파일 시스템 관찰 결과, 실행 비교               | 네이티브 PTY를 지원하는 Linux/macOS; [프로세스 캡처](../process-capture.md)                                                       |
 
 정적 JavaScript 및 .NET 검사는 제공된 파일을 읽으며 애플리케이션을 실행하지 않습니다. 런타임 캡처는 사용자의 권한으로 선택한 대상을 실행하거나 대상과 상호작용합니다. 각 런타임 가이드에서 그 영향을 설명합니다.
 
-오프라인 네이티브 바이너리 검사에는 호출자가 제공하는 GNU objdump와 Rizin도 사용할 수 있습니다. 제공자 설정, CLI 명령, Evidence의 한계는 [리버스 엔지니어링 도구 가이드](../reverse-engineering-tools.md)를 참고하세요. REA는 objdump와 Rizin을 설치하거나 업데이트하지 않습니다.
-
 <a id="choosing-a-deep-analysis-provider"></a>
 
-지원하는 네이티브 형식과 호스트는 제공자마다 다릅니다. [Hopper 및 Ghidra 설정](../installation.md#hopper), [IDA 가이드](../ida-provider.md)(선택 사항인 네이티브 MCP 브리지 포함), [실험적 Windows Ghidra 지원](../windows-ghidra-p0.md)을 참고하세요. Ghidra는 [16비트 DOS 분석](../ghidra-dos.md)도 지원합니다. 큰 바이너리를 분석할 때는 `REA_GHIDRA_STARTUP_TIMEOUT_MS` 또는 `REA_HOPPER_STARTUP_TIMEOUT_MS`로 제공자의 시작 제한 시간을 늘리세요. 제공자 선택은 [CLI 가이드](../cli.md#choose-a-provider)를 참고하세요. 최신 npm 릴리스 이후 추가된 기능은 [릴리스에서의 사용 가능 여부](../installation.md#released-package-and-main)를 확인하세요.
+지원하는 네이티브 형식과 호스트는 제공자마다 다릅니다. [Hopper 및 Ghidra 설정](../installation.md#hopper), [IDA 가이드](../ida-provider.md), [실험적 Windows Ghidra 지원](../windows-ghidra-p0.md)을 참고하세요. Ghidra는 [16비트 DOS 분석](../ghidra-dos.md)도 지원합니다. 제공자 선택은 [CLI 가이드](../cli.md#choose-a-provider)를 참고하세요. 최신 npm 릴리스 이후 추가된 기능은 [릴리스에서의 사용 가능 여부](../installation.md#released-package-and-main)를 확인하세요.
 
 ## 사례
 
@@ -216,7 +209,7 @@ REA로 흥미로운 대상을 분석했다면 알려 주세요. [issue](https://
 <details>
 <summary><strong>Hopper를 먼저 실행해야 하나요?</strong></summary>
 
-REA는 작업에 필요할 때 Hopper를 실행합니다. macOS에서는 처음 실행할 때 데모 모드를 선택하거나 라이선스를 활성화하라는 대화 상자가 나타날 수 있습니다. 첫 CLI/MCP 작업이나 무인 작업을 실행하기 전에 같은 사용자 세션에서 이 대화 상자를 완료하세요. 필요하면 Hopper를 직접 여세요. [Hopper 실행 및 문제 해결](../installation.md#launcher-paths-and-troubleshooting)을 참고하세요.
+REA는 작업에 필요할 때 Hopper를 실행합니다. macOS에서는 처음 실행할 때 데모 모드를 선택하거나 라이선스를 활성화하라는 대화 상자가 나타날 수 있습니다. [Hopper 실행 및 문제 해결](../installation.md#launcher-paths-and-troubleshooting)을 참고하세요.
 
 </details>
 
@@ -246,7 +239,7 @@ REA는 대상을 로컬에서 분석합니다. 에이전트는 도구 결과를
 
 먼저 업데이트하세요. 최근 릴리스에서 이미 수정되었을 수 있습니다.
 
-`npm install --global` 또는 `bun add --global`로 설치한 CLI에서는 다음 명령을 사용합니다.
+npm으로 설치한 CLI에서는 다음 명령을 사용합니다.
 
 ```bash
 rea update
@@ -293,10 +286,12 @@ REA를 사용하고, 버그를 보고하고, 기능을 요청하고, 빌드를
 
 책임 있는 사용에 관한 안내는 [DISCLAIMER.md](../../DISCLAIMER.md)를 참고하세요.
 
-불법적이거나 허가되지 않은 사용에 대한 프로젝트의 입장은 모든 REA 버전, 배포 채널, 플랫폼에 적용되며, 각 사본에는 해당 라이선스가 그대로 유지됩니다.
-
 REA는 법을 준수하는 연구, 교육, 상호운용성 확보, 소프트웨어 보존, 그리고 본인이 소유하거나 조사 권한을 가진 소프트웨어의 분석을 위한 도구입니다.
 
+The project's position on illegal or unauthorized use covers all REA
+versions, distribution channels, and platforms; each copy retains its
+applicable licenses.
+
 ## 기여
 
 REA에 도움을 보태 주세요! [issue를 등록](https://github.com/morluto/rea/issues)해 버그나 기능을 제안하거나, [pull request를 보내](https://github.com/morluto/rea/pulls) 코드와 문서를 개선할 수 있습니다.
@@ -307,6 +302,14 @@ REA에 도움을 보태 주세요! [issue를 등록](https://github.com/morluto/
 
 [MIT](../../LICENSE)
 
-REA가 작성한 코드는 MIT 라이선스를 따릅니다. 제3자 자료에는 각자의 라이선스와 저작권 고지가 그대로 유지됩니다. 의존성 목록, 보존된 라이선스 원문, 외부 도구 약관은 [제3자 고지](../../THIRD_PARTY_NOTICES.md)를 참고하세요.
+REA-authored code is licensed under MIT. Third-party material retains its own
+licenses and copyright notices; see [Third-party notices](../../THIRD_PARTY_NOTICES.md)
+for the dependency inventory, preserved license texts, and external-tool terms.
 
-IDA Pro / Hex-Rays 디컴파일러, Hopper, JEB 등 상용 도구는 해당 라이선스에 따라 **합법적으로 취득하고 사용 권한을 갖춰야 합니다.** REA는 어떤 도구의 라이선스, 키, 활성화 권한도 부여하지 않습니다. 체험판과 데모는 사용자, 기능, 자동화, 출력 공유 제한을 포함한 공급업체 약관을 따릅니다. 크랙 버전, 도난 키, 무단 키 공유, 라이선스 제한 우회는 허용되지 않습니다. 이 안내는 MIT 라이선스나 제3자 라이선스를 변경하지 않습니다.
+**You must legally obtain and be authorized to use commercial tools**, including
+IDA Pro / Hex-Rays decompilers, Hopper, and JEB, under their applicable licenses.
+REA grants no tool license, key, or activation entitlement. Trials and demos
+remain subject to vendor terms, including user, feature, automation, and output
+sharing restrictions. Cracked copies, stolen keys, unauthorized key sharing,
+and bypassing license restrictions are not authorized. This guidance does not
+amend MIT or third-party licenses.

package.json

@@ -138,7 +138,7 @@
     "test": "npm run test:with-build",
     "test:with-build": "npm run test:prepare && vitest run",
     "test:run": "vitest run",
-    "test:python": "python3 -m unittest bridge/native/test_rea_lldb_tracer.py -v && python3 -m unittest discover -s experiments/analysis-efficiency -p 'test_*.py' -v",
+    "test:python": "python3 -m unittest bridge/native/test_rea_lldb_tracer.py bridge/mitmproxy/test_capture.py -v && python3 -m unittest discover -s experiments/analysis-efficiency -p 'test_*.py' -v",
     "test:local": "node scripts/run-development-tests.mjs local",
     "test:fast": "node scripts/ci/test-group.mjs source",
     "test:built": "node scripts/ci/test-group.mjs built",

scripts/lib/clean-linux-hopper-runtime.d.mts

@@ -1,4 +1,5 @@
 export function assertCleanLinuxHopperRuntime(
   launcherPaths?: readonly string[],
   procRoot?: string,
+  listProcesses?: () => Promise<{ stdout: string }>,
 ): Promise<void>;

scripts/lib/clean-linux-hopper-runtime.mjs

@@ -17,8 +17,9 @@ export const assertCleanLinuxHopperRuntime = async (
       : [process.env.HOPPER_LAUNCHER_PATH]),
   ],
   procRoot = "/proc",
+  listProcesses = () => execFileAsync("ps", ["-ax", "-o", "command="]),
 ) => {
-  const { stdout } = await execFileAsync("ps", ["-ax", "-o", "command="]);
+  const { stdout } = await listProcesses();
   if (/\/opt\/hopper\/bin\/Hopper|\bXvfb\b|hopper-demo-x11\.py/u.test(stdout))
     throw new Error("Clean Linux runner retained a Hopper demo process");
   const launchers = [];

scripts/verify-windows-native-inspection.mjs

@@ -1,12 +1,11 @@
 import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import {
-  access,
   copyFile,
   mkdir,
   mkdtemp,
-  readFile,
   readdir,
+  rmdir,
   rm,
   stat,
   symlink,
@@ -55,7 +54,7 @@ try {
     join(workspace, "dist", "windows", "WindowsNativeLoader.js"),
   ).href;
   const source = `import assert from 'node:assert/strict';
-import {existsSync,mkdirSync,readFileSync,readdirSync,renameSync,statSync,writeFileSync} from 'node:fs';
+import {existsSync,mkdirSync,readdirSync,renameSync,statSync} from 'node:fs';
 import {join} from 'node:path';
 import {systemWindowsNativeAuthority} from ${JSON.stringify(loader)};
 const temp=process.env.TEMP;
@@ -65,61 +64,46 @@ assert.equal(first.retryable,true);
 assert.match(first.reason,/Delete owned object by handle failed.*Win32 5/s);
 const [name,...extra]=readdirSync(temp);assert.ok(name);assert.equal(extra.length,0);
 const path=join(temp,name);const identity=statSync(path,{bigint:true});
-// Delete sharing permits rename; ownership follows the retained NTFS handle.
-writeFileSync(join(path,'owned-child.txt'),'owned child');
-const renamed=path+'-renamed';renameSync(path,renamed);
-const moved=statSync(renamed,{bigint:true});
-assert.equal(moved.dev,identity.dev);assert.equal(moved.ino,identity.ino);
+// Ownership follows the retained NTFS handle even when the directory moves.
+// A replacement at its old pathname must remain caller-owned.
+const moved=path+'-renamed';renameSync(path,moved);
+assert.equal(statSync(moved,{bigint:true}).ino,identity.ino);
 mkdirSync(path);const replacement=statSync(path,{bigint:true});
 assert.notEqual(replacement.ino,identity.ino);
-const sentinel=join(path,'unrelated.txt');writeFileSync(sentinel,'unrelated replacement');
 if(process.argv[2]!=='teardown'){
  const second=systemWindowsNativeAuthority();assert.equal(second.available,true);
- assert.equal(existsSync(renamed),false);
+ assert.equal(existsSync(moved),false);
  assert.deepEqual(readdirSync(temp),[name]);
- assert.equal(readFileSync(sentinel,'utf8'),'unrelated replacement');
  assert.equal(statSync(path,{bigint:true}).ino,replacement.ino);
  assert.equal(systemWindowsNativeAuthority(),second);
 }
-console.log(JSON.stringify({mode:process.argv[2],firstFailed:true,retainedOwner:true,name,renamed,device:identity.dev.toString(),inode:identity.ino.toString(),replacementInode:replacement.ino.toString()}));
+console.log(JSON.stringify({mode:process.argv[2],firstFailed:true,retainedOwner:true,inode:identity.ino.toString(),replacementName:name,replacementInode:replacement.ino.toString()}));
 `;
   const fixture = join(workspace, "probe.mjs");
   await writeFile(fixture, source);
   for (const mode of ["retry", "teardown"]) {
     const temp = join(workspace, mode);
     await mkdir(temp);
-    const child = spawnSync(process.execPath, [fixture, mode], {
-      encoding: "utf8",
-      timeout: 20_000,
-      windowsHide: true,
-      env: { ...process.env, TEMP: temp, TMP: temp },
-    });
-    if (child.error !== undefined) throw child.error;
-    assert.equal(child.status, 0, child.stderr);
-    assert.equal(
-      child.stderr,
-      "",
-      "Native environment teardown reported a cleanup failure",
+    const observed = JSON.parse(
+      execFileSync(process.execPath, [fixture, mode], {
+        encoding: "utf8",
+        timeout: 20_000,
+        windowsHide: true,
+        env: { ...process.env, TEMP: temp, TMP: temp },
+      }),
     );
-    const observed = JSON.parse(child.stdout);
-    assert.equal(observed.mode, mode);
-    assert.equal(observed.firstFailed, true);
     assert.equal(observed.retainedOwner, true);
-    await assert.rejects(access(observed.renamed), { code: "ENOENT" });
-    assert.deepEqual(await readdir(temp), [observed.name]);
-    const replacement = join(temp, observed.name);
-    const identity = await stat(replacement, { bigint: true });
-    assert.equal(identity.dev.toString(), observed.device);
-    assert.equal(identity.ino.toString(), observed.replacementInode);
-    assert.notEqual(identity.ino.toString(), observed.inode);
-    assert.deepEqual(await readdir(replacement), ["unrelated.txt"]);
+    assert.deepEqual(await readdir(temp), [observed.replacementName]);
+    const replacement = join(temp, observed.replacementName);
     assert.equal(
-      await readFile(join(replacement, "unrelated.txt"), "utf8"),
-      "unrelated replacement",
+      (await stat(replacement, { bigint: true })).ino.toString(),
+      observed.replacementInode,
     );
+    await rmdir(replacement);
+    assert.deepEqual(await readdir(temp), []);
   }
   process.stdout.write(
-    `${JSON.stringify({ ok: true, controlledDispositionFailure: true, retainedOwner: true, renamedOwnerCleansChildren: true, unrelatedReplacementPreserved: true, retryRecovers: true, successfulAdmissionCached: true, environmentTeardownCleansProbe: true, issue1701HostCauseReproduced: false })}\n`,
+    `${JSON.stringify({ ok: true, controlledDispositionFailure: true, retainedOwner: true, renamedOwnerCleanup: true, replacementPreserved: true, retryRecovers: true, successfulAdmissionCached: true, environmentTeardownCleansProbe: true, issue1701HostCauseReproduced: false })}\n`,
   );
 } finally {
   await rm(workspace, { recursive: true, force: true });

src/application/ClientConfigurationDocument.ts

@@ -167,7 +167,7 @@ export const parseZcodeFallbackConfiguration = (
         ? {}
         : requireObject(document.mcpServers, "ZCode fallback mcpServers"),
     serversPath: ["mcpServers"],
-    dialect: "zcode_fallback",
+    dialect: "json",
     legacyServers: {},
   };
 };
@@ -183,7 +183,6 @@ export const parseClientConfiguration = (
   if (format === undefined || format === "unsupported")
     throw new TypeError("client does not have a supported MCP config format");
   // DeepSeek Harness stores a Cordis patch list, not a server table.
-  if (format === "zcode_fallback") return parseZcodeFallbackConfiguration(text);
   if (format === "dsh") return parseDshCordisDocument(text);
   const document = parseDocument(text, format);
   const serversKey = clientConfigurationServersKey(format);

src/application/ReferenceSourceImport.ts

@@ -12,7 +12,7 @@ import type { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.j
 import type { AnalysisCleanupObservation } from "../domain/analysisErrorBase.js";
 import { readReferenceSource } from "../reference/ReferenceSourceReader.js";
 import type {
-  ReferenceSourceExclusionKind,
+  ReferenceSourceEntryKind,
   ReferenceSourceRead,
   ReferenceSourceReaderError,
 } from "../reference/ReferenceSourceReaderTypes.js";
@@ -111,8 +111,7 @@ const deriveInventoryState = (
       entry.limitations.length > 0 ||
       (entry.kind === "file" && entry.content_state !== "hashed") ||
       (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-      (entry.kind === "symlink" && entry.target_state !== "internal") ||
-      entry.kind === "unknown",
+      (entry.kind === "symlink" && entry.target_state !== "internal"),
   );
   if (partialEntry) return "partial";
   const partialRelationship = input.relationships.some(
@@ -143,24 +142,11 @@ const createShouldExclude =
     exclusions: HistoricalSourceGraphInput["exclusions"],
     secrets: PreparedReferenceSourceImport["secrets"],
     ignored: PreparedReferenceSourceImport["ignored"],
-  ): ((path: string, kind: ReferenceSourceExclusionKind) => boolean) =>
+  ): ((path: string, kind: ReferenceSourceEntryKind) => boolean) =>
   (path, kind) => {
-    // An entry of unknown kind may be a directory, so directory-only rules
-    // must still exclude it; this fails closed for caller-marked secrets.
-    const patternPaths =
-      kind === "directory"
-        ? [`${path}/`]
-        : kind === "unknown"
-          ? [path, `${path}/`]
-          : [path];
-    const firstMatch = (matcher: typeof secrets) => {
-      const results = patternPaths.map((patternPath) =>
-        matcher.test(patternPath),
-      );
-      return results.find(({ ignored }) => ignored) ?? results[0];
-    };
-    const secretMatch = firstMatch(secrets);
-    if (secretMatch?.ignored === true) {
+    const patternPath = kind === "directory" ? `${path}/` : path;
+    const secretMatch = secrets.test(patternPath);
+    if (secretMatch.ignored) {
       if (!secretMatch.rule)
         throw new Error(`Ignored secret path has no matching rule: ${path}`);
       exclusions.push({
@@ -170,8 +156,8 @@ const createShouldExclude =
       });
       return true;
     }
-    const match = firstMatch(ignored);
-    if (match?.ignored !== true) return false;
+    const match = ignored.test(patternPath);
+    if (!match.ignored) return false;
     if (!match.rule)
       throw new Error(`Ignored path has no matching rule: ${path}`);
     const reason = match.rule.mark;

src/application/ReferenceSourceImportEntries.ts

@@ -45,8 +45,6 @@ const entryRecoveryGuidance = (
     return "This directory could not be read. Check its permissions, then try again.";
   if (entry.kind === "symlink")
     return "This symbolic link could not be read safely. Check the link and its permissions, then try again.";
-  if (entry.kind === "unknown")
-    return "This entry's type could not be determined. Check the parent directory and try again.";
   return "This file could not be read. Check its permissions, then try again.";
 };
 
@@ -75,13 +73,6 @@ const failedEntry = (
       classifications,
       limitations: [limitation],
     };
-  if (entry.kind === "unknown")
-    return {
-      path: entry.path,
-      kind: "unknown",
-      classifications: ["unknown"],
-      limitations: [limitation],
-    };
   return {
     path: entry.path,
     kind: "file",

src/application/SupportedClients.ts

@@ -47,7 +47,6 @@ export interface SetupClient {
     | "pi"
     | "kimi"
     | "hermes"
-    | "zcode_fallback"
     | "zcode"
     | "dsh"
     | "unsupported";

src/application/Uninstall.ts

@@ -231,21 +231,12 @@ export const systemUninstallHost = (
       const clients = supportedClients(home, platform, environment);
       redirection = appDataRedirection(clients);
       return Promise.resolve(
-        clients.flatMap((client) => [
-          ...uninstallConfigPaths(client).map((configPath) => ({
+        clients.flatMap((client) =>
+          uninstallConfigPaths(client).map((configPath) => ({
             ...client,
             configPath,
           })),
-          ...(client.zcodeFallbackPath === undefined
-            ? []
-            : [
-                {
-                  ...client,
-                  configPath: client.zcodeFallbackPath,
-                  format: "zcode_fallback" as const,
-                },
-              ]),
-        ]),
+        ),
       );
     },
     inspectClient: async (client) => {

src/domain/callPath.ts

@@ -1,4 +1,3 @@
-import { relationshipCoverageLimitations } from "./relationshipCoverage.js";
 import {
   callPathInputSchema,
   callPathResultSchema,
@@ -241,12 +240,15 @@ const inspectSearch = ({
       const coverage = snapshot.evidence.relationship_coverage;
       for (const limitation of snapshot.limitations)
         limitations.push(limitation);
-      if (coverage !== null) {
-        for (const limitation of relationshipCoverageLimitations(coverage))
+      if (coverage?.status === "partial")
+        for (const limitation of coverage.limitations)
           limitations.push(limitation);
-        for (const diagnostic of coverage.diagnostics ?? [])
-          limitations.push(diagnostic);
-      }
+      else if (coverage?.status === "unknown")
+        limitations.push(coverage.reason);
+      for (const diagnostic of coverage !== null && "diagnostics" in coverage
+        ? coverage.diagnostics
+        : [])
+        limitations.push(diagnostic);
       // The requested goal is a terminal for this search. Its outgoing edges
       // cannot add a path to the goal, so its dossier limits are contextual
       // but do not make the searched start-to-goal closure incomplete.

src/domain/functionCallCoverage.ts

@@ -1,7 +1,4 @@
-import {
-  relationshipCoverageLimitations,
-  type RelationshipCoverage,
-} from "./relationshipCoverage.js";
+import type { RelationshipCoverage } from "./relationshipCoverage.js";
 import type { FunctionDossier } from "./hopperValues.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
 
@@ -18,7 +15,11 @@ export const combineFunctionRelationshipCoverage = (
     { direction: "callees" as const, coverage: callees },
   ];
   const diagnostics = uniqueSorted(
-    reads.flatMap(({ coverage }) => coverage?.diagnostics ?? []),
+    reads.flatMap(({ coverage }) =>
+      coverage !== undefined && "diagnostics" in coverage
+        ? coverage.diagnostics
+        : [],
+    ),
   );
   const details = diagnostics.length > 0 ? { diagnostics } : {};
   const callersLimited = callers?.status !== "complete";
@@ -34,9 +35,15 @@ export const combineFunctionRelationshipCoverage = (
   const reasons = reads.flatMap(({ direction, coverage }) => {
     const label =
       direction === "callers" ? callerCoveragePrefix : calleeCoveragePrefix;
-    return relationshipCoverageLimitations(coverage).map(
-      (reason) => `${label}${reason}`,
-    );
+    const limitations =
+      coverage === undefined
+        ? ["Provider did not report relationship coverage."]
+        : coverage.status === "unknown"
+          ? [coverage.reason]
+          : coverage.status === "partial"
+            ? coverage.limitations
+            : [];
+    return limitations.map((reason) => `${label}${reason}`);
   });
   if (
     reads.some(
@@ -83,11 +90,24 @@ export const functionCallCoverageLimitations = (
   coverage: RelationshipCoverage | null,
   dossier: Pick<FunctionDossier, "unresolved_calls">,
 ): string[] => {
-  return uniqueSorted([
-    ...relationshipCoverageLimitations(coverage),
-    ...(coverage?.status === "complete" ? [] : (coverage?.diagnostics ?? [])),
+  const limitations =
+    coverage === null
+      ? ["Provider did not report relationship coverage."]
+      : coverage.status === "unknown"
+        ? [
+            coverage.reason,
+            ...("diagnostics" in coverage ? coverage.diagnostics : []),
+          ]
+        : coverage.status === "partial"
+          ? [
+              ...coverage.limitations,
+              ...("diagnostics" in coverage ? coverage.diagnostics : []),
+            ]
+          : [];
+  limitations.push(
     ...(dossier.unresolved_calls ?? []).map(
       ({ address, reason }) => `Unresolved call at ${address}: ${reason}`,
     ),
-  ]);
+  );
+  return uniqueSorted(limitations);
 };

src/domain/recordedTransportUrl.test.ts

@@ -0,0 +1,11 @@
+import { expect, it } from "vitest";
+
+import { parseRecordedTransportUrl } from "./recordedTransportUrl.js";
+
+it("recognizes an empty userinfo marker at the authority start", () => {
+  expect(parseRecordedTransportUrl("https://@host")).toMatchObject({
+    origin: "https://host",
+    path: "/",
+    credentials: { start: 8, end: 9 },
+  });
+});

src/domain/referenceSourceGraph.test.ts

@@ -259,30 +259,6 @@ describe("historical source graph", () => {
 });
 
 describe("partial historical source graphs", () => {
-  it("keeps unknown-entry diagnostics outside the root commitment", () => {
-    const base = graphInput();
-    base.inventory_state = "partial";
-    base.entries[2] = {
-      path: "src/package.json",
-      kind: "unknown",
-      classifications: ["unknown"],
-      limitations: ["Permission denied at /private/first"],
-    };
-    const graph = createHistoricalSourceGraph(base);
-    const changedMessage = structuredClone(base);
-    changedMessage.entries[2] = {
-      path: "src/package.json",
-      kind: "unknown",
-      classifications: ["unknown"],
-      limitations: ["Permission denied at /private/second"],
-    };
-    const revised = createHistoricalSourceGraph(changedMessage);
-    expect(revised.root_sha256).toBe(graph.root_sha256);
-    expect(computeHistoricalSourceGraphSha256(revised)).not.toBe(
-      computeHistoricalSourceGraphSha256(graph),
-    );
-  });
-
   it("keeps an unreadable symlink target unknown and out of root identity", () => {
     const base = graphInput();
     base.inventory_state = "partial";

src/domain/referenceSourceGraph.ts

@@ -111,10 +111,6 @@ const sourceEntrySchema = z.union([
   sourceFileSchema,
   sourceDirectorySchema,
   sourceSymlinkSchema,
-  z.strictObject({
-    ...entryBaseShape,
-    kind: z.literal("unknown"),
-  }),
 ]);
 
 const sourceRelationshipSchema = z.strictObject({
@@ -365,8 +361,7 @@ const checkCompleteInventory = (
       entry.limitations.length > 0 ||
       (entry.kind === "file" && entry.content_state !== "hashed") ||
       (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-      (entry.kind === "symlink" && entry.target_state !== "internal") ||
-      entry.kind === "unknown",
+      (entry.kind === "symlink" && entry.target_state !== "internal"),
   );
   const partialRelationship = graph.relationships.some(
     ({ parse_state, resolution }) =>
@@ -483,11 +478,6 @@ const rootCommitment = (
           target: entry.target,
           target_state: entry.target_state,
         };
-      case "unknown":
-        return {
-          kind: entry.kind,
-          path: entry.path,
-        };
     }
   }),
   exclusions,

src/domain/referenceSourceSummary.test.ts

@@ -81,26 +81,6 @@ describe("committed historical-source summaries", () => {
     expect(graph).toEqual(original);
   });
 
-  it("counts entries of unknown kind separately from symlinks", () => {
-    const graph = createHistoricalSourceGraph(
-      input([
-        {
-          path: "deep",
-          kind: "unknown",
-          classifications: ["unknown"],
-          limitations: ["lstat: ENAMETOOLONG"],
-        },
-      ]),
-    );
-    expect(createHistoricalSourceSummary(graph, 1).counts).toMatchObject({
-      entries: 1,
-      files: 0,
-      directories: 0,
-      symlinks: 0,
-      unknown: 1,
-    });
-  });
-
   it("sums known bytes losslessly beyond the JSON safe integer range", () => {
     const graph = createHistoricalSourceGraph(
       input(

src/domain/referenceSourceSummary.ts

@@ -29,7 +29,6 @@ export const createHistoricalSourceSummary = (
     files: 0,
     directories: 0,
     symlinks: 0,
-    unknown: 0,
     relationships: graph.relationships.length,
     parse_failures: graph.parse_failures.length,
     exclusions: graph.exclusions.length,
@@ -60,8 +59,7 @@ export const createHistoricalSourceSummary = (
     } else if (entry.kind === "directory") {
       counts.directories += 1;
       treeStates[entry.tree_state] += 1;
-    } else if (entry.kind === "symlink") counts.symlinks += 1;
-    else counts.unknown += 1;
+    } else counts.symlinks += 1;
     // Canonical entries already use Unicode code-point order; filtering preserves it.
     if (entry.path.split("/").length <= outlineDepth)
       outline.push(outlineEntry(entry));

src/domain/relationshipCoverage.ts

@@ -33,19 +33,3 @@ export const relationshipCoverageSchema = z.discriminatedUnion("status", [
 ]);
 
 export type RelationshipCoverage = z.infer<typeof relationshipCoverageSchema>;
-
-/** Reasons the observed relationship inventory cannot establish completeness. */
-export const relationshipCoverageLimitations = (
-  coverage: RelationshipCoverage | null | undefined,
-): readonly string[] => {
-  switch (coverage?.status) {
-    case undefined:
-      return ["Provider did not report relationship coverage."];
-    case "complete":
-      return [];
-    case "partial":
-      return coverage.limitations;
-    case "unknown":
-      return [coverage.reason];
-  }
-};

src/generatedPackageMetadata.ts

@@ -5,5 +5,5 @@ export const PACKAGE_METADATA = {
   serverSdkVersion: "2.3.1",
   clientSdkVersion: "2.3.1",
   coreSdkVersion: "2.3.1",
-  skillVersion: "42",
+  skillVersion: "41",
 } as const;

src/reference/ReferenceSourceReaderEntries.ts

@@ -25,7 +25,7 @@ import {
 import type {
   PendingDirectory,
   ReferenceSourceEntry,
-  ReferenceSourceExclusionKind,
+  ReferenceSourceEntryKind,
   ReferenceSourceResult,
   TraversalState,
 } from "./ReferenceSourceReaderTypes.js";
@@ -201,13 +201,6 @@ const processEntry = async (
   const metadata = await readMetadata(absolute);
   if (isAborted(state.signal)) return { ok: false, error: cancelled() };
   if (!metadata.ok) {
-    const excluded = applyExclusion(state.shouldExclude, path, "unknown");
-    if (!excluded.ok)
-      return {
-        ok: false,
-        error: failure("io", "Reference source exclusion check failed"),
-      };
-    if (excluded.value) return { ok: true, value: undefined };
     state.entries.push(entryFailure(path, "unknown", "io", metadata.message));
     return { ok: true, value: undefined };
   }
@@ -378,10 +371,10 @@ const readSymlinkTarget = async (
 
 const applyExclusion = (
   shouldExclude:
-    | ((path: string, kind: ReferenceSourceExclusionKind) => boolean)
+    | ((path: string, kind: ReferenceSourceEntryKind) => boolean)
     | undefined,
   path: string,
-  kind: ReferenceSourceExclusionKind,
+  kind: ReferenceSourceEntryKind,
 ): { readonly ok: true; readonly value: boolean } | { readonly ok: false } => {
   try {
     return { ok: true, value: shouldExclude?.(path, kind) === true };

src/reference/ReferenceSourceReaderErrors.ts

@@ -29,9 +29,6 @@ const FILESYSTEM_ERROR_CODES = new Set([
   "EISDIR",
   "ELOOP",
   "EMFILE",
-  // A traversed child can exceed the platform's absolute path limit even
-  // though the selected root and every component are valid.
-  "ENAMETOOLONG",
   "ENFILE",
   "ENOENT",
   "ENOTDIR",
@@ -47,8 +44,6 @@ export const filesystemFailureDetail = (
 ): string | undefined => {
   if (!(cause instanceof Error)) return undefined;
   const code: unknown = Reflect.get(cause, "code");
-  if (code === "ENAMETOOLONG")
-    return `${operation}: ENAMETOOLONG (entry path exceeds the operating system path limit)`;
   return typeof code === "string" && FILESYSTEM_ERROR_CODES.has(code)
     ? `${operation}: ${cause.message}`
     : undefined;

src/reference/ReferenceSourceReaderTypes.ts

@@ -10,17 +10,11 @@ export type ReferenceSourceEntryKind =
   | "symlink"
   | "other";
 
-/**
- * Kind offered to exclusion predicates. `unknown` marks an entry whose
- * metadata could not be read, so its concrete kind cannot be claimed.
- */
-export type ReferenceSourceExclusionKind = ReferenceSourceEntryKind | "unknown";
-
 export interface ReferenceSourceReaderOptions {
   readonly signal?: AbortSignal;
   readonly shouldExclude?: (
     path: string,
-    kind: ReferenceSourceExclusionKind,
+    kind: ReferenceSourceEntryKind,
   ) => boolean;
 }
 
@@ -90,7 +84,7 @@ export type TraversalState = {
   readonly signal?: AbortSignal;
   readonly shouldExclude?: (
     path: string,
-    kind: ReferenceSourceExclusionKind,
+    kind: ReferenceSourceEntryKind,
   ) => boolean;
   readonly entries: ReferenceSourceEntry[];
   readonly pending: PendingDirectory[];

tests/boundary/android/JadxAnalysis.test.ts

@@ -279,44 +279,26 @@ it("preserves bounded instruction coverage separately from using-node coverage",
   });
 });
 
-it.each([
-  "not-a-dex-descriptor",
-  "(Lbad(name;)V",
-  "(Lbad)name;)V",
-  "()Lbad(name;",
-  "()Lbad)name;",
-])(
-  "rejects malformed DEX prototype %s at the adapter boundary",
-  async (descriptor) => {
-    const invalidSummary = {
-      ...summary,
-      methods: summary.methods.map((method) => ({
-        ...method,
-        dex_descriptor: descriptor,
-      })),
-    };
-    await expect(
-      analyzeJadxRequest(
-        {
-          json: () => Promise.resolve(invalidSummary),
-          text: () => Promise.reject(new Error("unexpected text call")),
-        },
-        {
-          operation: "inspect_android_class",
-          input: { path: "/fixture.apk", class_name: "fixture.Target" },
-        },
-        {} as never,
-        engine,
-      ),
-    ).rejects.toMatchObject({
-      _tag: "AnalysisOutputError",
-      cause: {
-        issues: expect.arrayContaining([
-          expect.objectContaining({
-            path: ["methods", 0, "dex_descriptor"],
-          }),
-        ]),
+it("rejects malformed method descriptors at the Android adapter boundary", async () => {
+  const invalidSummary = {
+    ...summary,
+    methods: summary.methods.map((method) => ({
+      ...method,
+      dex_descriptor: "not-a-dex-descriptor",
+    })),
+  };
+  await expect(
+    analyzeJadxRequest(
+      {
+        json: () => Promise.resolve(invalidSummary),
+        text: () => Promise.reject(new Error("unexpected text call")),
       },
-    });
-  },
-);
+      {
+        operation: "inspect_android_class",
+        input: { path: "/fixture.apk", class_name: "fixture.Target" },
+      },
+      {} as never,
+      engine,
+    ),
+  ).rejects.toThrow();
+});

tests/boundary/filesystem/referenceSourceFailureDetails.test.ts

@@ -133,88 +133,3 @@ describe("reference import native entry failure details", () => {
     ).toMatchObject({ kind: "file", content_state: "hashed", limitations: [] });
   });
 });
-
-describe("reference import paths beyond the platform limit", () => {
-  it.skipIf(process.platform === "win32")(
-    "reports an entry beyond the absolute path limit as an I/O failure",
-    async () => {
-      const root = await createTestTempDirectory("rea-import-deep-path-");
-      await writeFile(join(root, "kept.txt"), "k");
-      // Relative creation lets the tree exceed PATH_MAX (1024 on macOS, 4096
-      // on Linux) while each 200-byte component stays below NAME_MAX.
-      const deepTree = (action: "create" | "remove") =>
-        promisify(execFile)(process.execPath, [
-          "-e",
-          `const fs = require("node:fs");
-          const names = Array.from({ length: 24 }, (_, i) => "d" + String(i).padStart(2, "0") + "x".repeat(197));
-          process.chdir(${JSON.stringify(root)});
-          if (${JSON.stringify(action)} === "create") {
-            for (const name of names) { fs.mkdirSync(name); process.chdir(name); }
-            fs.writeFileSync("deep.txt", "d");
-          } else {
-            for (const name of names) process.chdir(name);
-            fs.rmSync("deep.txt");
-            for (const name of [...names].reverse()) { process.chdir(".."); fs.rmdirSync(name); }
-          }`,
-        ]);
-      await deepTree("create");
-      try {
-        const read = await readReferenceSource(root);
-        if (!read.ok) throw new Error(read.error.message);
-        expect(read.value.entries).toContainEqual(
-          expect.objectContaining({ path: "kept.txt", status: "read" }),
-        );
-        const failed = read.value.entries.find(
-          (entry) => entry.status === "failed",
-        );
-        expect(failed).toMatchObject({
-          status: "failed",
-          code: "io",
-          message: expect.stringContaining("ENAMETOOLONG"),
-        });
-        const filteredRead = await readReferenceSource(root, {
-          shouldExclude: (path, kind) =>
-            path === failed?.path && kind === "directory",
-        });
-        if (!filteredRead.ok) throw new Error(filteredRead.error.message);
-        expect(
-          filteredRead.value.entries.find(
-            (entry) => entry.path === failed?.path,
-          ),
-        ).toMatchObject({ status: "failed", kind: "unknown", code: "io" });
-        const imported = await importTree(root);
-        if (!imported.ok) throw new Error(imported.error.message);
-        expect(imported.value.entries).toContainEqual(
-          expect.objectContaining({
-            path: "kept.txt",
-            content_state: "hashed",
-          }),
-        );
-        const deep = imported.value.entries.find(
-          (entry) => entry.path === failed?.path,
-        );
-        expect(deep?.limitations.join(" ")).toContain(
-          failed?.status === "failed" ? failed.message : "missing failure",
-        );
-        // A directory-only secret rule still applies when the kind is unknown.
-        const secretPattern = `${failed?.path ?? "missing"}/`;
-        const secret = await importReferenceSource({
-          root,
-          caller: "native-entry-failure-detail-test",
-          policy: { secretPatterns: [secretPattern] },
-        });
-        if (!secret.ok) throw new Error(secret.error.message);
-        expect(
-          secret.value.entries.some(({ path }) => path === failed?.path),
-        ).toBe(false);
-        expect(secret.value.exclusions).toContainEqual({
-          path: failed?.path,
-          reason: "configured-secret",
-          pattern: secretPattern,
-        });
-      } finally {
-        await deepTree("remove");
-      }
-    },
-  );
-});

tests/boundary/filesystem/zcodeClientConfiguration.test.ts

@@ -13,10 +13,7 @@ import {
 } from "../../../src/application/SetupClientConfiguration.js";
 import { skillDestinations } from "../../../src/application/SetupSkill.js";
 import { supportedClients } from "../../../src/application/SupportedClients.js";
-import {
-  runUninstall,
-  systemUninstallHost,
-} from "../../../src/application/Uninstall.js";
+import { systemUninstallHost } from "../../../src/application/Uninstall.js";
 import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
 import { clearClientLocationEnvironment } from "../../fixtures/clientEnvironment.js";
 
@@ -260,91 +257,6 @@ describe("ZCode .agents fallback preservation", () => {
   });
 });
 
-describe("ZCode fallback uninstall", () => {
-  const owned = { command: command[0], args: command.slice(1) };
-  const writeFallback = async (home: string, servers: object) => {
-    await mkdir(join(home, ".agents"), { recursive: true });
-    const text = `${JSON.stringify({ ui: { keep: true }, mcpServers: servers }, null, 2)}\n`;
-    await writeFile(fallbackPath(home), text);
-    return text;
-  };
-
-  it.each(["comment", "trailing-comma", "bom"])(
-    "fails closed on strict fallback syntax: %s",
-    async (mode) => {
-      const { home } = await zcodeClient();
-      const valid = await writeFallback(home, {
-        rea: owned,
-        other: { command: "other-server" },
-      });
-      const original =
-        mode === "comment"
-          ? `// unsupported comment\n${valid}`
-          : mode === "bom"
-            ? `\uFEFF${valid}`
-            : valid.replace(/\}\s*$/u, ",}");
-      await writeFile(fallbackPath(home), original);
-      const result = await runUninstall(false, systemUninstallHost(home));
-      expect(result.items).toContainEqual(
-        expect.objectContaining({ name: "zcode", status: "failed" }),
-      );
-      expect(await readFile(fallbackPath(home), "utf8")).toBe(original);
-      await expect(
-        readFile(`${fallbackPath(home)}.rea.backup`),
-      ).rejects.toMatchObject({ code: "ENOENT" });
-    },
-  );
-
-  it("removes the REA-owned fallback entry with the native registration", async () => {
-    const { home, client } = await zcodeClient();
-    await writeFile(
-      client.configPath,
-      JSON.stringify({ mcp: { servers: { rea: owned } } }),
-    );
-    const original = await writeFallback(home, {
-      rea: owned,
-      other: { command: "other-server" },
-    });
-
-    const result = await runUninstall(false, systemUninstallHost(home));
-
-    expect(result.status).toBe("complete");
-    expect(result.items.find(({ name }) => name === "zcode")?.status).toBe(
-      "removed",
-    );
-    const native = JSON.parse(await readFile(client.configPath, "utf8"));
-    expect(native.mcp.servers).toEqual({});
-    const fallback = JSON.parse(await readFile(fallbackPath(home), "utf8"));
-    expect(fallback).toEqual({
-      ui: { keep: true },
-      mcpServers: { other: { command: "other-server" } },
-    });
-    expect(await readFile(`${fallbackPath(home)}.rea.backup`, "utf8")).toBe(
-      original,
-    );
-  });
-
-  it("removes a fallback-only REA entry and keeps a foreign rea entry", async () => {
-    for (const [servers, expected] of [
-      [{ rea: owned }, {}],
-      [
-        { rea: { command: "someone-else" } },
-        { rea: { command: "someone-else" } },
-      ],
-    ] as const) {
-      const { home } = await zcodeClient();
-      await writeFallback(home, servers);
-
-      expect(
-        (await runUninstall(false, systemUninstallHost(home))).status,
-      ).toBe("complete");
-      expect(
-        JSON.parse(await readFile(fallbackPath(home), "utf8")).mcpServers,
-      ).toEqual(expected);
-    }
-  });
-});
-
 describe("ZCode fallback admission", () => {
   it.each([{ PORT: 123 }, { REA_MCP_INPUT_SCHEMA_PROFILE: "unknown" }])(
     "refuses malformed fallback REA environment %j before native writes",

tests/process-global/cleanLinuxHopperRuntime.test.ts

@@ -34,6 +34,10 @@ it
     const procRoot = join(directory, "proc");
     await mkdir(procRoot);
     const alternateMode = mode === "alternate launcher";
+    let orphanPid: number | undefined;
+    const isolatedProcessList = async () => ({
+      stdout: alternateMode || orphanPid === undefined ? "" : "Xvfb",
+    });
     if (alternateMode) {
       await copyFile("/usr/bin/sleep", launcher);
       await chmod(launcher, 0o700);
@@ -47,6 +51,7 @@ it
     await assertCleanLinuxHopperRuntime(
       alternateMode ? [launcher] : [],
       procRoot,
+      isolatedProcessList,
     );
     const command = alternateMode ? alternate : process.execPath;
     const arguments_ = alternateMode ? ["30"] : ["-e", childCode];
@@ -69,7 +74,6 @@ it
     const parentPid = parent.child.pid;
     if (parentPid === undefined)
       throw new Error("Fixture parent did not spawn");
-    let orphanPid: number | undefined;
     try {
       const { stdout } = await parent;
       const { pid } = JSON.parse(stdout) as { pid: number };
@@ -115,6 +119,7 @@ it
         assertCleanLinuxHopperRuntime(
           alternateMode ? [launcher] : [],
           procRoot,
+          isolatedProcessList,
         ),
       ).rejects.toThrow("Clean Linux runner retained a Hopper demo process");
       // Observation must not terminate the fixture, even though it resembles Xvfb.