rea-agents 2.4.0 → 2.5.0

package/bridge/hopper_bridge.py

@@ -11,19 +11,86 @@ import os
 import re
 import sre_parse
 import socket
+from typing import Any, Optional, Protocol, Sequence
 
 MAX_LINE_BYTES = 10 * 1024 * 1024
+MAX_READ_BYTES = 4096
 BAD_ADDRESSES = (-1, 0xFFFFFFFFFFFFFFFF, None)
 _selected_document = None
 _search_inventory_cache = {}
+_pseudocode_cache = {}
+_hopper_api = None
 MAX_SEARCH_PATTERN_LENGTH = 256
 MAX_SEARCH_VALUE_LENGTH = 4096
 
 
+class HopperDocument(Protocol):
+    """Typed minimum used by the provider-neutral Hopper API facade."""
+
+    def getDocumentName(self) -> str: ...
+
+    def getExecutableFilePath(self) -> Optional[str]: ...
+
+    def getDatabaseFilePath(self) -> Optional[str]: ...
+
+    def backgroundProcessActive(self) -> bool: ...
+
+
+class HopperDocumentProvider(Protocol):
+    """Hopper's injected global document provider."""
+
+    @classmethod
+    def getAllDocuments(cls) -> Sequence[HopperDocument]: ...
+
+    @classmethod
+    def getCurrentDocument(cls) -> Optional[HopperDocument]: ...
+
+
+class HopperApiFacade:
+    """Small injected boundary around Hopper globals for standalone tests."""
+
+    def __init__(self, document_provider: HopperDocumentProvider):
+        self._document_provider = document_provider
+
+    def documents(self) -> Sequence[HopperDocument]:
+        return self._document_provider.getAllDocuments()
+
+    def current_document(self) -> Optional[HopperDocument]:
+        return self._document_provider.getCurrentDocument()
+
+    def require_analysis_complete(
+        self, document: HopperDocument, operation: str
+    ) -> None:
+        if document.backgroundProcessActive():
+            raise CapabilityUnavailableError(
+                "%s requires completed Hopper background analysis" % operation
+            )
+
+
+def _configure_hopper_api(document_provider):
+    """Inject Hopper's document provider or a standalone test facade."""
+    global _hopper_api
+    _hopper_api = HopperApiFacade(document_provider)
+
+
+def _api():
+    """Resolve Hopper globals lazily so importing this module needs no Hopper."""
+    global _hopper_api
+    if _hopper_api is not None:
+        return _hopper_api
+    document_provider = globals().get("Document")
+    if document_provider is None:
+        raise CapabilityUnavailableError(
+            "Hopper Document API is unavailable outside the Hopper runtime"
+        )
+    _hopper_api = HopperApiFacade(document_provider)
+    return _hopper_api
+
+
 def _session_document():
     """Find only the document opened for this authenticated REA session."""
     target = os.path.realpath(REA_TARGET_PATH)
-    for document in Document.getAllDocuments():
+    for document in _api().documents():
         paths = (document.getExecutableFilePath(), document.getDatabaseFilePath())
         for path in paths:
             if path and os.path.realpath(path) == target:
@@ -36,6 +103,31 @@ MAX_REGEX_CANDIDATE_LENGTH = 4096
 MAX_REGEX_SEARCH_WORK_UNITS = 1000000
 
 
+class CapabilityUnavailableError(Exception):
+    """The active Hopper build lacks one admitted public API operation."""
+
+
+EXHAUSTIVE_ANALYSIS_METHODS = frozenset(
+    (
+        "analyze_function",
+        "list_names",
+        "list_procedures",
+        "list_strings",
+        "procedure_address",
+        "procedure_assembly",
+        "procedure_callees",
+        "procedure_callers",
+        "procedure_info",
+        "procedure_pseudo_code",
+        "procedure_references",
+        "read_function_instructions",
+        "resolve_containing_procedure",
+        "search_procedures",
+        "search_strings",
+    )
+)
+
+
 def _hex(value):
     return "0x%x" % value
 
@@ -54,7 +146,8 @@ def _json_safe(value):
 def _document(name=None):
     """Resolve an explicit or session-selected document without changing Hopper UI."""
     global _selected_document
-    documents = Document.getAllDocuments()
+    api = _api()
+    documents = api.documents()
     if name is not None:
         for candidate in documents:
             if candidate.getDocumentName() == name:
@@ -64,7 +157,7 @@ def _document(name=None):
         for candidate in documents:
             if candidate.getDocumentName() == _selected_document:
                 return candidate
-    current = Document.getCurrentDocument()
+    current = api.current_document()
     if current is None:
         raise ValueError("No Hopper document is loaded")
     return current
@@ -225,12 +318,35 @@ def _invalidate_search_inventory(document):
             del _search_inventory_cache[key]
 
 
+def _invalidate_pseudocode(document):
+    """Discard cached decompilation after an analysis annotation changes."""
+    document_id = id(document)
+    for key in list(_pseudocode_cache):
+        if key[0] == document_id:
+            del _pseudocode_cache[key]
+
+
+def _pseudocode(document, procedure):
+    """Reuse one provider decompilation for repeated bounded projections."""
+    key = (id(document), procedure.getEntryPoint())
+    if key not in _pseudocode_cache:
+        _pseudocode_cache[key] = procedure.decompile()
+    return _pseudocode_cache[key]
+
+
 def _search_inventory(document, kind):
     """Cache an immutable, address-sorted inventory for an unchanged document."""
     key = (id(document), kind)
     inventory = _search_inventory_cache.get(key)
     if inventory is None:
-        values = _procedure_map(document) if kind == "procedure" else _strings(document)
+        if kind == "procedure":
+            values = _procedure_map(document)
+        elif kind == "string":
+            values = _strings(document)
+        elif kind == "name":
+            values = {_hex(address): value for address, value in _name_map(document).items()}
+        else:
+            raise ValueError("Unknown inventory kind")
         inventory = tuple(sorted(values.items(), key=lambda item: int(item[0], 16)))
         _search_inventory_cache[key] = inventory
     return inventory
@@ -507,6 +623,22 @@ def _name_map(document):
     return result
 
 
+def _render_instruction(segment, address):
+    instruction = segment.getInstructionAtAddress(address)
+    if instruction is None:
+        return None
+    arguments = [
+        instruction.getFormattedArgument(index)
+        for index in range(instruction.getArgumentCount())
+    ]
+    suffix = ", ".join(value for value in arguments if value is not None)
+    return "%s: %s%s" % (
+        _hex(address),
+        instruction.getInstructionString(),
+        (" " + suffix) if suffix else "",
+    )
+
+
 def _assembly(procedure, limit=None):
     """Render bounded assembly while guarding against malformed instruction cycles."""
     lines = []
@@ -520,9 +652,9 @@ def _assembly(procedure, limit=None):
             instruction = segment.getInstructionAtAddress(address)
             if instruction is None:
                 break
-            arguments = [instruction.getFormattedArgument(index) for index in range(instruction.getArgumentCount())]
-            suffix = ", ".join(value for value in arguments if value is not None)
-            lines.append("%s: %s%s" % (_hex(address), instruction.getInstructionString(), (" " + suffix) if suffix else ""))
+            line = _render_instruction(segment, address)
+            if line is not None:
+                lines.append(line)
             if limit is not None and len(lines) >= limit:
                 return "\n".join(lines)
             length = instruction.getInstructionLength()
@@ -532,6 +664,45 @@ def _assembly(procedure, limit=None):
     return "\n".join(lines)
 
 
+def _read_function_instructions(document, params):
+    """Read one bounded raw-instruction window without invoking decompilation."""
+    procedure = _procedure(document, params.get("procedure"))
+    offset = _offset(params, "offset")
+    limit = params.get("limit", 64)
+    if offset > 100000:
+        raise ValueError("offset must not exceed 100000")
+    if not isinstance(limit, int) or isinstance(limit, bool) or limit < 1 or limit > 500:
+        raise ValueError("limit must be an integer between 1 and 500")
+    addresses, scan_truncated = _instruction_addresses(
+        procedure, offset + limit + 1
+    )
+    start = min(offset, len(addresses))
+    end = min(len(addresses), start + limit)
+    segment = procedure.getSegment()
+    items = []
+    for address in addresses[start:end]:
+        line = _render_instruction(segment, address)
+        if line is not None:
+            items.append(line)
+    has_more = scan_truncated or end < len(addresses)
+    return {
+        "procedure": _procedure_identity(procedure),
+        "instructions": {
+            "items": items,
+            "total": None if scan_truncated else len(addresses),
+            "returned": len(items),
+            "truncated": has_more,
+            "next_offset": end if has_more else None,
+        },
+        "instructions_scanned": len(addresses),
+        "instruction_scan_truncated": scan_truncated,
+        "limitations": [
+            "Instruction text and ordering are Hopper-specific representations.",
+            "The fast path does not decompile the procedure or scan whole-program names and strings.",
+        ],
+    }
+
+
 def _analyze_function(document, params):
     """Collect a bounded, single-pass function dossier for agent callers."""
     procedure = _procedure(document, params.get("procedure"))
@@ -560,8 +731,8 @@ def _analyze_function(document, params):
             "end": _hex(block.getEndingAddress()),
             "successors": sorted(set(successors), key=lambda value: int(value, 16)),
         })
-    pseudo = procedure.decompile() or ""
-    assembly_lines = _assembly(procedure).splitlines() if params.get("include_assembly", False) else []
+    pseudo = _pseudocode(document, procedure) or ""
+    assembly_lines = _assembly(procedure, max_instructions).splitlines() if params.get("include_assembly", False) else []
     callers = sorted((_procedure_identity(item) for item in procedure.getAllCallerProcedures()), key=lambda item: int(item["address"], 16))
     callees = sorted((_procedure_identity(item) for item in procedure.getAllCalleeProcedures()), key=lambda item: int(item["address"], 16))
     comments = []
@@ -595,8 +766,14 @@ def _analyze_function(document, params):
             incoming.append(item)
         if source in procedure_addresses:
             outgoing.append(item)
-    string_map = {int(address, 16): value for address, value in _strings(document).items()}
-    name_map = _name_map(document)
+    string_map = {
+        int(address, 16): value
+        for address, value in _search_inventory(document, "string")
+    }
+    name_map = {
+        int(address, 16): value
+        for address, value in _search_inventory(document, "name")
+    }
     referenced_strings = []
     referenced_names = []
     for edge in outgoing:
@@ -615,7 +792,13 @@ def _analyze_function(document, params):
     return {
         "procedure": {"address": _hex(procedure.getEntryPoint()), "name": _procedure_name(procedure), "classification": None, "signature": procedure.signatureString(), "locals": _procedure_locals(procedure)},
         "pseudocode": {"text": pseudo_text, "total_chars": len(pseudo), "returned_chars": len(pseudo_text), "truncated": pseudo_next < len(pseudo), "next_offset": pseudo_next if pseudo_next < len(pseudo) else None},
-        "assembly": _bounded(assembly_lines, assembly_offset, max_instructions),
+        "assembly": _bounded(
+            assembly_lines,
+            assembly_offset,
+            max_instructions,
+            None,
+            instruction_scan_truncated if params.get("include_assembly", False) else False,
+        ),
         "comments": collection("comments", comments, instruction_scan_truncated),
         "callers": collection("callers", callers), "callees": collection("callees", callees),
         "incoming_references": collection("incoming_references", incoming, instruction_scan_truncated),
@@ -671,9 +854,54 @@ def _dispatch(method, params):
         return _selected_document
 
     document = _document(params.get("document"))
+    if method in EXHAUSTIVE_ANALYSIS_METHODS:
+        _api().require_analysis_complete(document, method)
 
     if method == "analyze_function":
         return _analyze_function(document, params)
+    if method == "read_function_instructions":
+        return _read_function_instructions(document, params)
+    if method == "read_bytes":
+        length = params.get("length", 256)
+        if isinstance(length, bool) or not isinstance(length, int):
+            raise ValueError("Byte-read length must be an integer")
+        if length < 1 or length > MAX_READ_BYTES:
+            raise ValueError("Byte-read length must be between 1 and 4096")
+        reader = getattr(document, "readBytes", None)
+        if not callable(reader):
+            raise CapabilityUnavailableError(
+                "Hopper's public Python API does not expose readBytes"
+            )
+        address = _address(document, params.get("address"))
+        value = reader(address, length)
+        if not isinstance(value, (bytes, bytearray)):
+            raise CapabilityUnavailableError(
+                "Hopper's public Python API returned an unsupported byte representation"
+            )
+        data = bytes(value)
+        return {
+            "address": _hex(address),
+            "requested_bytes": length,
+            "returned_bytes": len(data),
+            "bytes_hex": data.hex(),
+            "complete": len(data) == length,
+        }
+    if method == "address_to_file_offset":
+        mapper = getattr(document, "getFileOffsetFromAddress", None)
+        if not callable(mapper):
+            raise CapabilityUnavailableError(
+                "Hopper's public Python API does not expose getFileOffsetFromAddress"
+            )
+        address = _address(document, params.get("address"))
+        offset = mapper(address)
+        if (
+            isinstance(offset, bool)
+            or not isinstance(offset, int)
+            or offset in BAD_ADDRESSES
+            or offset < 0
+        ):
+            raise ValueError("Address has no authoritative file-offset mapping")
+        return {"address": _hex(address), "file_offset": offset}
     if method == "resolve_containing_procedure":
         address = _address(document, params.get("address"))
         procedure, reason = _containing_procedure(document, address)
@@ -740,19 +968,16 @@ def _dispatch(method, params):
             })
         return result
     if method == "list_procedures":
-        return _page(_procedure_map(document), params.get("offset", 0), params.get("limit", 100))
+        return _page(dict(_search_inventory(document, "procedure")), params.get("offset", 0), params.get("limit", 100))
     if method == "list_strings":
-        values = _strings(document)
+        values = dict(_search_inventory(document, "string"))
         requested = params.get("address")
         if requested is not None:
             key = _hex(_address(document, requested))
             values = {key: values[key]} if key in values else {}
         return _page(values, params.get("offset", 0), params.get("limit", 100))
     if method == "list_names":
-        result = {}
-        for segment in document.getSegmentsList():
-            for item in segment.getNamedAddresses():
-                result[_hex(item)] = segment.getNameAtAddress(item)
+        result = dict(_search_inventory(document, "name"))
         requested = params.get("address")
         if requested is not None:
             key = _hex(_address(document, requested))
@@ -768,7 +993,7 @@ def _dispatch(method, params):
         if method == "procedure_assembly":
             return _assembly(procedure)
         if method == "procedure_pseudo_code":
-            return procedure.decompile()
+            return _pseudocode(document, procedure)
         if method == "procedure_callers":
             return sorted((_hex(item.getEntryPoint()) for item in procedure.getAllCallerProcedures()), key=lambda value: int(value, 16))
         if method == "procedure_callees":
@@ -779,12 +1004,18 @@ def _dispatch(method, params):
             return {"name": _procedure_name(procedure), "entrypoint": _hex(procedure.getEntryPoint()), "basicblock_count": procedure.getBasicBlockCount(), "length": length, "signature": procedure.signatureString(), "locals": _procedure_locals(procedure), "classification": None}
     if method == "set_address_name":
         address = _address(document, params.get("address"))
-        result = document.setNameAtAddress(address, params["name"])
-        _invalidate_search_inventory(document)
+        try:
+            result = document.setNameAtAddress(address, params["name"])
+        finally:
+            _invalidate_search_inventory(document)
+            _invalidate_pseudocode(document)
         return result
     if method == "set_addresses_names":
-        result = {key: document.setNameAtAddress(_address(document, key), value) for key, value in params["names"].items()}
-        _invalidate_search_inventory(document)
+        try:
+            result = {key: document.setNameAtAddress(_address(document, key), value) for key, value in params["names"].items()}
+        finally:
+            _invalidate_search_inventory(document)
+            _invalidate_pseudocode(document)
         return result
     if method in ("set_comment", "set_inline_comment"):
         address = _address(document, params.get("address"))
@@ -792,6 +1023,7 @@ def _dispatch(method, params):
         setter = segment.setCommentAtAddress if method == "set_comment" else segment.setInlineCommentAtAddress
         getter = segment.getCommentAtAddress if method == "set_comment" else segment.getInlineCommentAtAddress
         setter(address, params["comment"])
+        _invalidate_pseudocode(document)
         return getter(address) == params["comment"]
     if method == "list_bookmarks":
         return [{"address": _hex(item), "name": document.getBookmarkName(item)} for item in document.getBookmarks()]
@@ -838,6 +1070,8 @@ def _serve_connection(connection):
 
 
 def _diagnostic_type(error):
+    if isinstance(error, CapabilityUnavailableError):
+        return "capability_unavailable"
     if isinstance(error, PermissionError):
         return "authorization"
     if isinstance(error, (ValueError, TypeError, KeyError)):
@@ -864,4 +1098,5 @@ def _run():
 
 # Hopper's public objects are bound to its dedicated Python execution thread.
 # Keep dispatch on that thread; moving calls to an arbitrary worker can deadlock.
-_run()
+if __name__ == "__main__":
+    _run()

package/dist/application/AnalysisClientCleanup.js

@@ -0,0 +1,14 @@
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { err, ok } from "../domain/result.js";
+/** Close one provider client and normalize unexpected adapter rejection. */
+export const closeAnalysisClient = async (client, providerId, options = {}) => {
+    try {
+        if (client.closeWithOutcome !== undefined)
+            return await client.closeWithOutcome(options);
+        await client.close();
+        return ok(null);
+    }
+    catch (cause) {
+        return err(new ProviderCleanupError(providerId, ["provider-client"], { reason: "provider client close rejected unexpectedly" }, { cause }));
+    }
+};

package/dist/application/ApplicationWorkflowEvidenceResolver.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
-import { compareApplicationVersionsRequestSchema, compareJavaScriptExportShapesRequestSchema, traceApplicationFeatureRequestSchema, traceJavaScriptSemanticsRequestSchema, } from "../contracts/applicationWorkflowInputContracts.js";
+import { compareApplicationVersionsRequestSchema, compareJavaScriptExportShapesRequestSchema, compareSourceToBundleRequestSchema, traceApplicationFeatureRequestSchema, traceJavaScriptSemanticsRequestSchema, } from "../contracts/applicationWorkflowInputContracts.js";
 import { AnalysisInputError } from "../domain/errors.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
 import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
 import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
 import { traceJavaScriptSemanticsInputSchema } from "../domain/javascriptSemanticTraceSchemas.js";
+import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
 import { err, ok } from "../domain/result.js";
 import { resolveEvidenceReferences, } from "./EvidenceReferenceResolver.js";
 const APPLICATION_GRAPH_IDENTITIES = [
@@ -35,18 +36,14 @@ export const resolveTraceApplicationFeatureRequest = (input, lookup) => {
 };
 /** Resolve a trace request already parsed by the caller-facing contract. */
 export const resolveTraceApplicationFeatureRequestValidated = (input, lookup) => {
-    const application = input.application === undefined
-        ? resolveEvidenceReferences(lookup, input.application_evidence_id === undefined
-            ? []
-            : [input.application_evidence_id], APPLICATION_GRAPH_IDENTITIES)
-        : ok([input.application]);
+    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
     if (!application.ok)
         return application;
     const native = resolveEvidenceReferences(lookup, input.native_observation_evidence_ids);
     if (!native.ok)
         return native;
     const raw = {
-        application: application.value[0],
+        application: application.value,
         native_observations: [...input.native_observations, ...native.value],
         seed: input.seed,
         direction: input.direction,
@@ -66,14 +63,10 @@ export const resolveTraceJavaScriptSemanticsRequest = (input, lookup) => {
 };
 /** Resolve a semantic trace request already parsed by its public contract. */
 export const resolveTraceJavaScriptSemanticsRequestValidated = (input, lookup) => {
-    const application = input.application === undefined
-        ? resolveEvidenceReferences(lookup, input.application_evidence_id === undefined
-            ? []
-            : [input.application_evidence_id], APPLICATION_GRAPH_IDENTITIES)
-        : ok([input.application]);
+    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
     if (!application.ok)
         return application;
-    const raw = { application: application.value[0], query: input.query };
+    const raw = { application: application.value, query: input.query };
     const parsed = traceJavaScriptSemanticsInputSchema.safeParse(raw);
     return parsed.success
         ? ok(parsed.data)
@@ -121,6 +114,31 @@ export const resolveCompareApplicationVersionsRequestValidated = (input, lookup)
         ? ok(parsed.data)
         : invalid("compare_application_versions", parsed.error, raw);
 };
+/** Parse and resolve one historical-source comparison adapter request. */
+export const resolveCompareSourceToBundleRequest = (input, lookup) => {
+    const parsed = compareSourceToBundleRequestSchema.safeParse(input);
+    return parsed.success
+        ? resolveCompareSourceToBundleRequestValidated(parsed.data, lookup)
+        : invalid("compare_source_to_bundle", parsed.error, input);
+};
+/** Resolve a historical-source comparison request parsed by its public contract. */
+export const resolveCompareSourceToBundleRequestValidated = (input, lookup) => {
+    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
+    if (!application.ok)
+        return application;
+    const raw = {
+        reference: input.reference,
+        application: application.value,
+        limits: input.limits,
+        ...(input.unknown_registry_approved === undefined
+            ? {}
+            : { unknown_registry_approved: input.unknown_registry_approved }),
+    };
+    const parsed = compareSourceToBundleInputSchema.safeParse(raw);
+    return parsed.success
+        ? ok(parsed.data)
+        : invalid("compare_source_to_bundle", parsed.error, raw);
+};
 /** Parse and resolve an export-shape adapter request into canonical input. */
 export const resolveCompareJavaScriptExportShapesRequest = (input, lookup) => {
     const parsed = compareJavaScriptExportShapesRequestSchema.safeParse(input);

package/dist/application/BinarySession.js

@@ -9,6 +9,7 @@ import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, } from "./BinarySessionOpen.js";
 import { prepareSessionExecution } from "./BinarySessionExecution.js";
+import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 /**
  * Owns the single active target shared by CLI and MCP adapters.
@@ -116,7 +117,14 @@ export class BinarySession extends BinarySessionRecords {
             await this.#drainCalls();
             const previous = this.#active;
             this.#active = undefined;
-            await previous?.client.close();
+            if (previous !== undefined) {
+                const closed = await closeAnalysisClient(previous.client, previous.route.identity.id);
+                if (!closed.ok) {
+                    this.clearSessionRecords();
+                    this.#clearRuntimeAvailability();
+                    return closed;
+                }
+            }
             const runId = randomUUID();
             const client = route.createClient(target, { runId });
             const started = await client.execute("health", {}, options);
@@ -157,15 +165,17 @@ export class BinarySession extends BinarySessionRecords {
         });
     }
     /** Close the active target, if any. */
-    close() {
+    close(options = {}) {
         return this.#serialize(async () => {
             const previous = this.#active;
             this.#active = undefined;
             await this.#drainCalls();
-            await previous?.client.close();
+            const closed = previous === undefined
+                ? ok(null)
+                : await closeAnalysisClient(previous.client, previous.route.identity.id, options);
             this.clearSessionRecords();
             this.#clearRuntimeAvailability();
-            return ok(null);
+            return closed;
         });
     }
     /** Describe the active binary session. */
@@ -177,6 +187,7 @@ export class BinarySession extends BinarySessionRecords {
             runtimeAvailability: this.#runtimeAvailability,
             runId: this.#active?.runId,
             runtimeLineageSnapshots: this.#active?.client.runtimeLineageSnapshots?.() ?? [],
+            requestActivitySnapshots: this.#active?.client.requestActivitySnapshots?.() ?? [],
         });
     }
     /** Return the immutable artifact identity captured before its provider started. */

package/dist/application/BinarySessionStatus.js

@@ -1,5 +1,5 @@
 /** Project internal provider routing state into the caller-visible session status. */
-export const binarySessionStatus = ({ target, route, router, runtimeAvailability, runId, runtimeLineageSnapshots, }) => {
+export const binarySessionStatus = ({ target, route, router, runtimeAvailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, }) => {
     const configuredProvider = router.configuredIdentity();
     const provider = providerSummary(configuredProvider);
     const providers = router.providerIdentities(route).map(providerSummary);
@@ -41,6 +41,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeAvailability
                 run_id: runId,
                 process_lineage: processLineageStatus(runtimeLineageSnapshots),
             },
+        analysis_activity: requestActivityStatus(requestActivitySnapshots),
     };
     return target === undefined
         ? { open: false, ...common }
@@ -54,6 +55,35 @@ export const binarySessionStatus = ({ target, route, router, runtimeAvailability
             architecture: target.architecture ?? null,
         };
 };
+const requestActivityStatus = (snapshots) => {
+    const providers = snapshots
+        .slice()
+        .sort((left, right) => left.provider.id.localeCompare(right.provider.id))
+        .map(({ provider, active, queuedRequests }) => ({
+        provider: providerSummary(provider),
+        active: active === null
+            ? null
+            : {
+                request_id: active.requestId,
+                operation: active.operation,
+                elapsed_ms: active.elapsedMs,
+                timeout_ms: active.timeoutMs,
+                caller_state: active.callerState,
+            },
+        queued_requests: queuedRequests,
+    }));
+    const active = snapshots.flatMap((snapshot) => snapshot.active === null ? [] : [snapshot.active]);
+    return {
+        status: snapshots.length === 0
+            ? "not_observed"
+            : active.some(({ callerState }) => callerState === "timed_out")
+                ? "timed_out_busy"
+                : active.length > 0
+                    ? "busy"
+                    : "idle",
+        providers,
+    };
+};
 const providerSummary = ({ id, name, version, }) => ({ id, name, version });
 const processLineageStatus = (snapshots) => snapshots.length === 0
     ? { status: "not_observed" }

package/dist/application/BrowserEvidence.js

@@ -1,5 +1,6 @@
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
+import { commitBrowserScenarioNormalization } from "../domain/browserScenarioNormalization.js";
 /** Create Evidence v2 for a policy-scoped external browser observation. */
 export const createBrowserEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: browserPredicate(operation),
@@ -20,6 +21,18 @@ export const createBrowserEvidence = (operation, input, result, provider) => cre
 });
 const browserParameters = (input) => {
     if (!("cdp_endpoint" in input)) {
+        if ("before_scenario" in input &&
+            input.before_scenario !== undefined &&
+            input.after_scenario !== undefined)
+            return {
+                comparison_kind: "browser_scenario",
+                before_browser: input.before_scenario.browser,
+                after_browser: input.after_scenario.browser,
+                before_start_origin: input.before_scenario.scenario.start_origin,
+                after_start_origin: input.after_scenario.scenario.start_origin,
+                max_changes: input.max_changes,
+                normalization_sha256: commitBrowserScenarioNormalization(input.normalization).sha256,
+            };
         if ("max_changes" in input)
             return {
                 before_target_id: input.before.inspection.target.target_id,
@@ -74,6 +87,7 @@ const browserParameters = (input) => {
         include_websocket_shapes: input.include_websocket_shapes,
         include_script_sources: input.include_script_sources,
         include_storage_keys: input.include_storage_keys,
+        include_storage_fingerprints: input.include_storage_fingerprints,
         limits: input.limits,
         ...(input.include_script_sources && "source_capture_approved" in input
             ? {

package/dist/application/BrowserScenarioCapturePort.js

@@ -0,0 +1 @@
+export {};