rea-agents 6.1.0 → 6.3.0

package/dist/application/XrefsAddressResolution.js

@@ -0,0 +1,45 @@
+import { addressedValue } from "../contracts/toolOutputSchemaPrimitives.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { err, ok } from "../domain/result.js";
+import { resolveProcedureAddress } from "./ProcedureAddressResolution.js";
+/** Resolve a CLI symbol selector without changing existing address spellings. */
+export const resolveXrefsAddress = async (analysis, selector, signal) => {
+    if (selector.length === 0 ||
+        /^[0-9a-f]+$/iu.test(selector) ||
+        /^0x/iu.test(selector) ||
+        /:0x/iu.test(selector))
+        return ok(selector);
+    const inventory = await analysis.execute("list_names", {}, { signal });
+    if (!inventory.ok) {
+        if (inventory.error instanceof AnalysisCapabilityUnavailableError &&
+            inventory.error.operation === "list_names" &&
+            !inventory.error.cleanupIncomplete)
+            return resolveProcedureAddress(async (operation, parameters, signal) => {
+                const result = await analysis.execute(operation, parameters, signal === undefined ? {} : { signal });
+                return result.ok ? ok(result.value.result) : result;
+            }, selector, signal);
+        return inventory;
+    }
+    if (!Array.isArray(inventory.value.result))
+        return err(new AnalysisOutputError("list_names", "Expected a symbol inventory array"));
+    const addresses = new Set();
+    for (const [index, item] of inventory.value.result.entries()) {
+        const parsed = addressedValue.safeParse(item);
+        if (!parsed.success || parsed.data.address.length === 0)
+            return err(new AnalysisOutputError("list_names", `Invalid symbol inventory entry at index ${index}`));
+        if (parsed.data.value === selector)
+            addresses.add(parsed.data.address);
+    }
+    const [address] = addresses;
+    if (addresses.size === 1 && address !== undefined)
+        return ok(address);
+    return err(new AnalysisInputError("xrefs", undefined, [
+        {
+            path: ["address"],
+            reason: "invalid_value",
+            message: addresses.size === 0
+                ? `Unknown analyzed symbol name ${JSON.stringify(selector)}. Use an exact analyzed name or a hexadecimal address.`
+                : `Analyzed symbol name ${JSON.stringify(selector)} is ambiguous at ${[...addresses].join(", ")}. Select an exact address.`,
+        },
+    ]));
+};

package/dist/application/analysisView/AnalysisViewService.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { ANALYSIS_VIEW_PROVIDER } from "../InvestigationProviders.js";
+import { resolveEvidenceInput } from "../EvidenceInputResolver.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import { createEvidence, parseEvidence, } from "../../domain/evidence.js";
+import { INSPECT_ANALYSIS_VIEW_OPERATION, inspectAnalysisViewInputSchema, projectAnalysisView, } from "../../domain/analysisView/analysisView.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
+/** Authenticate a selected-view request and project already completed Evidence. */
+export const inspectAnalysisView = (rawInput, lookup) => {
+    const parsed = inspectAnalysisViewInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(analysisInputErrorFromIssues(INSPECT_ANALYSIS_VIEW_OPERATION, parsed.error.issues, rawInput, { cause: parsed.error }));
+    return inspectAnalysisViewValidated(parsed.data, lookup);
+};
+/** Project a view from input already parsed by a trusted adapter. */
+export const inspectAnalysisViewValidated = (input, lookup) => {
+    const resolved = resolveAnalysisViewSource(input.source, lookup);
+    if (!resolved.ok)
+        return resolved;
+    const parent = resolved.value;
+    const projected = projectAnalysisView({
+        evidenceId: parent.evidence_id,
+        operation: parent.operation,
+        normalizedResult: parent.normalized_result,
+        limitations: parent.limitations,
+    }, input.view);
+    if (!projected.ok)
+        return projected;
+    if (parent.subject !== null &&
+        parent.subject.digest.sha256 !== projected.value.artifact.sha256)
+        return err(new EvidenceIntegrityError(`Parent subject SHA-256 ${parent.subject.digest.sha256} differs from analysis artifact SHA-256 ${projected.value.artifact.sha256}.`));
+    return ok(createAnalysisViewEvidence(input, parent, projected.value));
+};
+const resolveAnalysisViewSource = (source, lookup) => {
+    if (source.kind === "retained-evidence")
+        return resolveEvidenceInput(source, lookup);
+    try {
+        return ok(parseEvidence(source.evidence));
+    }
+    catch (cause) {
+        if (cause instanceof z.ZodError)
+            return err(analysisInputErrorFromIssues(INSPECT_ANALYSIS_VIEW_OPERATION, cause.issues, source.evidence, { cause }));
+        if (cause instanceof TypeError)
+            return err(new EvidenceIntegrityError(cause.message, cause.message.length > 0 ? { userMessage: cause.message } : undefined));
+        throw cause;
+    }
+};
+const createAnalysisViewEvidence = (input, parent, result) => {
+    const target = parent.subject === null
+        ? undefined
+        : {
+            path: parent.subject.local_path,
+            sha256: parent.subject.digest.sha256,
+            format: parent.subject.format,
+            ...(parent.subject.architecture === null
+                ? {}
+                : { architecture: parent.subject.architecture }),
+        };
+    return createEvidence(target, ANALYSIS_VIEW_PROVIDER, {
+        predicateType: "rea.analysis-view",
+        operation: INSPECT_ANALYSIS_VIEW_OPERATION,
+        parameters: {
+            parent_evidence_id: parent.evidence_id,
+            view: jsonValueSchema.parse(input.view),
+        },
+        result: jsonValueSchema.parse(result),
+        rawResult: null,
+        confidence: "derived",
+        authority: parent.authority,
+        limitations: result.limitations,
+        locations: [{ kind: "artifact-path", path: result.artifact.path }],
+        evidenceLinks: [parent.evidence_id],
+    });
+};

package/dist/application/android/AndroidAnalysisService.js

@@ -17,7 +17,7 @@ export class AndroidAnalysisService {
         const request = androidRequestSchema.safeParse({ operation, input });
         if (!request.success)
             return err(new AnalysisInputError(operation, { cause: request.error }));
-        const target = await parseBinaryTarget(request.data.input.path);
+        const target = await parseBinaryTarget(request.data.input.path, options?.signal === undefined ? {} : { signal: options.signal });
         if (!target.ok)
             return target;
         const executed = await this.provider.execute(target.value, request.data, options);

package/dist/application/binary/AnalysisClientCleanup.js

@@ -1,14 +1,39 @@
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
-import { err, ok } from "../../domain/result.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
+import { err } from "../../domain/result.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.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);
+        return await client.close(options);
     }
     catch (cause) {
+        // A typed cleanup failure already names its leftover resources.
+        if (cause instanceof AnalysisError && cause.cleanupIncomplete)
+            return err(cause);
         return err(new ProviderCleanupError(providerId, ["provider-client"], { reason: "provider client close rejected unexpectedly" }, { cause }));
     }
 };
+/** Preserve the original lifecycle failure alongside incomplete cleanup. */
+export const analysisErrorWithCleanupFailure = (primary, cleanup, operation = "close_binary") => {
+    const projected = projectAnalysisError(cleanup);
+    return new ProviderAdapterError(cleanup instanceof ProviderAdapterError ? cleanup.providerId : "rea", operation, {
+        cause: primary,
+        userMessage: projectAnalysisError(primary).message,
+        ...(primary.capturedOutput === undefined
+            ? {}
+            : { capturedOutput: primary.capturedOutput }),
+        ...(primary.partialObservation === undefined
+            ? {}
+            : { partialObservation: primary.partialObservation }),
+        cleanup: {
+            reason: projected.message,
+            resources: cleanup.cleanupResources,
+        },
+        diagnostics: {
+            primary_error: projectAnalysisError(primary),
+            cleanup_error: projected,
+        },
+    });
+};

package/dist/application/binary/AnalysisProviderEvaluation.js

@@ -46,14 +46,13 @@ export const evaluateAnalysisProviderCandidate = async (candidate, status, targe
         if (resolved.value.profile === null)
             return ok(rejectedProfile(candidate, status, "Provider version or analysis profile could not be resolved"));
         const profile = analysisProfileSchema.parse(resolved.value.profile);
-        const compatibility = jsonObjectSchema.parse(resolved.value.compatibility);
         const identity = candidate.identity();
         if (profile.provider.id !== identity.id ||
             profile.provider.name !== identity.name ||
             (identity.version !== null &&
                 profile.provider.version !== identity.version))
             return ok(rejectedProfile(candidate, status, "Resolved analysis profile has mismatched provider identity"));
-        return ok({ candidate, status, profile, compatibility });
+        return ok({ candidate, status, profile });
     }
     catch (cause) {
         void cause;

package/dist/application/binary/AnalysisProviderRegistry.js

@@ -117,13 +117,11 @@ export class AnalysisProviderRegistry {
         if (evaluated.profileError !== undefined)
             return err(evaluated.profileError);
         const statuses = replaceCandidate(baseline, evaluated.status);
-        if (evaluated.profile === undefined ||
-            evaluated.compatibility === undefined)
+        if (evaluated.profile === undefined)
             return err(selectionError("provider_unavailable", providerId, statuses));
         return ok(selectedResult(providerId, source, {
             ...evaluated,
             profile: evaluated.profile,
-            compatibility: evaluated.compatibility,
         }, statuses));
     }
     async #selectAutomatically(context) {
@@ -149,8 +147,7 @@ export class AnalysisProviderRegistry {
             return result.value;
         });
         const statuses = evaluations.map(({ status }) => status);
-        const usable = evaluations.filter((evaluation) => evaluation.profile !== undefined &&
-            evaluation.compatibility !== undefined);
+        const usable = evaluations.filter((evaluation) => evaluation.profile !== undefined);
         if (usable.length === 0)
             return ok({
                 requestedProviderId: "auto",
@@ -195,7 +192,6 @@ const selectedResult = (requestedProviderId, source, evaluated, statuses) => {
             identity: structuredClone(evaluated.profile.provider),
             selectionSource: source,
             profile: structuredClone(evaluated.profile),
-            compatibility: structuredClone(evaluated.compatibility),
         },
         candidates: replaceCandidate(statuses, selectedStatus),
     };

package/dist/application/binary/AnalysisSnapshotCache.js

@@ -4,6 +4,7 @@ import {} from "../../domain/analysisErrorBase.js";
 import { err, ok } from "../../domain/result.js";
 import { analysisQueryId, createAnalysisSnapshotEntry, createAnalysisSnapshotWorkflowEntry, snapshotBinding, snapshotMatchesProfile, snapshotMatchesTarget, snapshotTarget, parseAnalysisSnapshot, } from "../../domain/analysisSnapshot.js";
 import { OFFICIAL_TOOL_CONTRACTS } from "../../contracts/officialToolContracts.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 const STATEFUL_OPERATIONS = new Set([
     "health",
     "current_address",
@@ -31,7 +32,8 @@ export const isSnapshotCacheable = (operation, descriptor, parameters) => !STATE
         typeof parameters.address === "string") &&
     descriptor?.effects.mutatesArtifact === false &&
     descriptor.cachePolicy !== "live" &&
-    descriptor.effects.mayWriteFilesystem === false &&
+    (descriptor.cachePolicy === "snapshot" ||
+        descriptor.effects.mayWriteFilesystem === false) &&
     descriptor.effects.changesPermissions === false;
 /** Bounded in-memory cache for one immutable binary identity. */
 export class AnalysisSnapshotCache {
@@ -72,7 +74,7 @@ export class AnalysisSnapshotCache {
                 imported += 1;
             this.#entries.set(entry.query_id, structuredClone(entry));
         }
-        for (const entry of snapshot.workflow_entries ?? []) {
+        for (const entry of snapshot.workflow_entries) {
             if (!this.#workflowEntries.has(entry.query_id) && !this.#hasCapacity())
                 continue;
             this.#workflowEntries.set(entry.query_id, structuredClone(entry));
@@ -86,15 +88,16 @@ export class AnalysisSnapshotCache {
         try {
             const snapshotTargetIdentity = snapshotTarget(target);
             const binding = snapshotBinding(profile);
-            const retainedEvidence = structuredClone(evidenceBundle);
+            const entries = [...this.#entries.values()].sort((left, right) => compareUnicodeCodePoints(left.query_id, right.query_id));
+            const workflows = [...this.#workflowEntries.values()].sort((left, right) => compareUnicodeCodePoints(left.query_id, right.query_id));
+            // Parsing owns the returned JSON and metadata; pre-cloning the same
+            // payloads here only adds another full materialization.
             return ok(parseAnalysisSnapshot({
                 target: snapshotTargetIdentity,
                 binding,
-                entries: this.entries(),
-                ...(this.workflowEntries().length === 0
-                    ? {}
-                    : { workflow_entries: this.workflowEntries() }),
-                evidence_bundle: retainedEvidence,
+                entries,
+                workflow_entries: workflows,
+                evidence_bundle: evidenceBundle,
             }));
         }
         catch (cause) {
@@ -124,13 +127,13 @@ export class AnalysisSnapshotCache {
     /** Return canonical entries for persistence. */
     entries() {
         return [...this.#entries.values()]
-            .sort((left, right) => left.query_id.localeCompare(right.query_id))
+            .sort((left, right) => compareUnicodeCodePoints(left.query_id, right.query_id))
             .map((entry) => structuredClone(entry));
     }
     /** Return canonical composed-workflow entries for persistence. */
     workflowEntries() {
         return [...this.#workflowEntries.values()]
-            .sort((left, right) => left.query_id.localeCompare(right.query_id))
+            .sort((left, right) => compareUnicodeCodePoints(left.query_id, right.query_id))
             .map((entry) => structuredClone(entry));
     }
     /** Record one exact derived workflow result unless the shared cache is full. */

package/dist/application/binary/BinarySession.js

@@ -13,7 +13,7 @@ import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, resolveSessionTarget, validateResolvedSessionTarget, } from "./BinarySessionOpen.js";
 import { bindExecutionTarget, commitExecutionProfile, prepareSessionExecution, } from "./BinarySessionExecution.js";
-import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
+import { analysisErrorWithCleanupFailure, closeAnalysisClient, } from "./AnalysisClientCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => name));
 /**
@@ -25,6 +25,7 @@ const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => na
  */
 export class BinarySession extends BinarySessionRecords {
     #active;
+    #pendingCleanup;
     #transition = Promise.resolve();
     #transitionGeneration = 0;
     #calls = new Map();
@@ -38,14 +39,14 @@ export class BinarySession extends BinarySessionRecords {
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
         const route = this.#currentRoute();
-        let selected = route.identity;
+        let selected = route.binding?.identity ?? route.identity;
         if (operation !== undefined) {
-            const exact = route.capabilities?.get(operation)?.provider;
+            const exact = route.capabilities.get(operation)?.provider;
             if (exact !== undefined)
                 selected = exact;
             else if (ENHANCED_OPERATIONS.has(operation)) {
                 const providers = new Map();
-                for (const descriptor of route.capabilities?.values() ?? [])
+                for (const descriptor of route.capabilities.values())
                     if (descriptor.available &&
                         OFFICIAL_OPERATIONS.has(descriptor.operation))
                         providers.set(descriptor.provider.id, descriptor.provider);
@@ -81,10 +82,6 @@ export class BinarySession extends BinarySessionRecords {
             return undefined;
         return structuredClone(profile);
     }
-    /** Return opaque adapter metadata retained for legacy open_binary output. */
-    openCompatibility() {
-        return structuredClone(this.#active?.compatibility ?? {});
-    }
     /** Observe runtime provider-health changes that affect discovery metadata. */
     onAvailabilityChanged(listener) {
         this.#availabilityListeners.add(listener);
@@ -134,7 +131,7 @@ export class BinarySession extends BinarySessionRecords {
             if (!resolved.ok)
                 return resolved;
             const { target, route, sameTarget } = resolved.value;
-            const { profile, compatibility } = route;
+            const { profile } = route;
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const activeProfile = this.#active?.profile;
@@ -142,6 +139,11 @@ export class BinarySession extends BinarySessionRecords {
                 ? profile === null
                 : profile !== null && analysisProfilesEqual(activeProfile, profile);
             await this.#drainCalls(admittedThrough);
+            if (isAborted(options.signal))
+                return err(new AnalysisCancelledError("open_binary"));
+            const pendingClosed = await this.#retryPendingCleanup();
+            if (!pendingClosed.ok)
+                return pendingClosed;
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             if (sameTarget && sameProfile) {
@@ -155,31 +157,28 @@ export class BinarySession extends BinarySessionRecords {
             const previous = this.#active;
             this.#active = undefined;
             if (previous !== undefined) {
-                const closed = await closeAnalysisClient(previous.client, previous.route.identity.id);
+                const closed = await this.#retireClient(previous.client, previous.route.identity.id);
                 if (!closed.ok) {
                     this.clearSessionRecords();
                     this.#clearRuntimeAvailability();
                     return closed;
                 }
             }
+            if (isAborted(options.signal))
+                return err(await this.#restoreAfterFailedOpen(previous, new AnalysisCancelledError("open_binary")));
             const runId = randomUUID();
             const client = route.createClient(target, { runId });
             const started = await client.execute("health", {}, options);
             if (!started.ok) {
-                await client.close();
-                await this.#restore(previous);
-                return started;
+                return err(await this.#failedOpen(client, route.identity.id, previous, started.error));
             }
             if (isAborted(options.signal)) {
-                await client.close();
-                await this.#restore(previous);
-                return err(new AnalysisCancelledError("open_binary"));
+                return err(await this.#failedOpen(client, route.identity.id, previous, new AnalysisCancelledError("open_binary")));
             }
             this.#active = {
                 target,
                 client,
                 profile,
-                compatibility: structuredClone(compatibility),
                 route,
                 runId,
             };
@@ -195,9 +194,7 @@ export class BinarySession extends BinarySessionRecords {
                 const imported = this.importAnalysisSnapshot(options.snapshot);
                 if (!imported.ok) {
                     this.#active = undefined;
-                    await client.close();
-                    await this.#restore(previous);
-                    return imported;
+                    return err(await this.#failedOpen(client, route.identity.id, previous, imported.error));
                 }
             }
             return ok(target);
@@ -222,7 +219,12 @@ export class BinarySession extends BinarySessionRecords {
                 return written;
             const closed = await this.#closeActive(options);
             return closed.ok
-                ? ok({ ...written.value, entries: snapshot.value.entries.length })
+                ? ok({
+                    ...written.value,
+                    primitive_entries: snapshot.value.entries.length,
+                    workflow_entries: snapshot.value.workflow_entries.length,
+                    evidence_records: snapshot.value.evidence_bundle.records.length,
+                })
                 : closed;
         });
     }
@@ -230,8 +232,8 @@ export class BinarySession extends BinarySessionRecords {
         const previous = this.#active;
         this.#active = undefined;
         const closed = previous === undefined
-            ? ok(null)
-            : await closeAnalysisClient(previous.client, previous.route.identity.id, {
+            ? await this.#retryPendingCleanup(options.progress, options.retainProviderDocuments)
+            : await this.#retireClient(previous.client, previous.route.identity.id, {
                 ...(options.progress === undefined
                     ? {}
                     : { progress: options.progress }),
@@ -243,6 +245,42 @@ export class BinarySession extends BinarySessionRecords {
         this.#clearRuntimeAvailability();
         return closed;
     }
+    async #retireClient(client, providerId, options = {}) {
+        this.#pendingCleanup = {
+            client,
+            providerId,
+            retainDocument: options.retainDocument === true,
+        };
+        return this.#retryPendingCleanup(options.progress);
+    }
+    async #retryPendingCleanup(progress, retainDocument) {
+        let pending = this.#pendingCleanup;
+        if (pending === undefined)
+            return ok(null);
+        if (retainDocument !== undefined) {
+            pending = { ...pending, retainDocument };
+            this.#pendingCleanup = pending;
+        }
+        const closed = await closeAnalysisClient(pending.client, pending.providerId, {
+            ...(progress === undefined ? {} : { progress }),
+            ...(pending.retainDocument ? { retainDocument: true } : {}),
+        });
+        if (closed.ok)
+            this.#pendingCleanup = undefined;
+        return closed;
+    }
+    async #failedOpen(client, providerId, previous, primary) {
+        const closed = await this.#retireClient(client, providerId);
+        if (!closed.ok)
+            return analysisErrorWithCleanupFailure(primary, closed.error, "open_binary");
+        return this.#restoreAfterFailedOpen(previous, primary);
+    }
+    async #restoreAfterFailedOpen(previous, primary) {
+        const restored = await this.#restore(previous);
+        return restored.ok
+            ? primary
+            : analysisErrorWithCleanupFailure(primary, restored.error, "open_binary");
+    }
     /** Describe the active binary session. */
     status() {
         return binarySessionStatus({
@@ -276,6 +314,22 @@ export class BinarySession extends BinarySessionRecords {
         this.#calls.set(call, generation);
         return call.finally(() => this.#calls.delete(call));
     }
+    /** Admit one composed request until its result and session bookkeeping settle. */
+    withAdmittedAnalysis(operationName, signal, operation) {
+        const generation = this.#transitionGeneration;
+        const transition = this.#transition;
+        const call = (async () => {
+            const admission = await this.#waitForTransition(operationName, signal, transition);
+            if (!admission.ok)
+                return admission;
+            return ok(await operation({
+                execute: (name, arguments_, options) => this.#execute(name, arguments_, options, Promise.resolve()),
+            }));
+        })();
+        // Register synchronously before a lifecycle transition can snapshot calls.
+        this.#calls.set(call, generation);
+        return call.finally(() => this.#calls.delete(call));
+    }
     async #execute(name, arguments_, options, transition) {
         const transitioned = await this.#waitForTransition(name, options?.signal, transition);
         if (!transitioned.ok)
@@ -328,7 +382,7 @@ export class BinarySession extends BinarySessionRecords {
                 execution: profiled.value,
             });
         }
-        else if (profiled.ok && capability?.effects.mutatesArtifact === true) {
+        else if (profiled.ok && capability.effects.mutatesArtifact) {
             this.invalidateSnapshot();
         }
         return profiled;
@@ -410,21 +464,24 @@ export class BinarySession extends BinarySessionRecords {
     }
     async #restore(previous) {
         if (previous === undefined)
-            return;
+            return ok(null);
         const runId = randomUUID();
         const client = previous.route.createClient(previous.target, { runId });
         const started = await client.execute("health", {});
-        if (started.ok)
+        if (started.ok) {
             this.#active = {
                 target: previous.target,
                 client,
                 profile: previous.profile,
-                compatibility: previous.compatibility,
                 route: previous.route,
                 runId,
             };
-        else
-            await client.close();
+            return ok(null);
+        }
+        const closed = await this.#retireClient(client, previous.route.identity.id);
+        return closed.ok
+            ? ok(null)
+            : err(analysisErrorWithCleanupFailure(started.error, closed.error, "open_binary"));
     }
     async #waitForTransition(operation, signal, transition) {
         if (signal?.aborted === true)

package/dist/application/binary/BinarySessionComposition.js

@@ -6,6 +6,4 @@ import { SessionProviderRouter } from "./SessionProviderRouter.js";
  * Compose one provider-neutral session from deep-provider selection and
  * disjoint auxiliary operation families.
  */
-export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
-    ? registry
-    : SessionProviderRouter.selectable(registry, auxiliaryProviders), new InvestigationRecords());
+export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(SessionProviderRouter.selectable(registry, auxiliaryProviders), new InvestigationRecords());

package/dist/application/binary/BinarySessionExecution.js

@@ -9,17 +9,15 @@ export const prepareSessionExecution = (input) => {
     const { active, operation, parameters, unboundOperationError, lookupSnapshot, } = input;
     if (active === undefined)
         return err(new NoBinaryOpenError());
-    const capability = active.route.capabilities?.get(operation);
-    if (active.route.capabilities !== undefined &&
-        capability?.available !== true) {
+    const capability = active.route.capabilities.get(operation);
+    if (capability?.available !== true) {
         const selectionError = unboundOperationError(operation, active.route);
         if (selectionError !== undefined)
             return err(selectionError);
         return err(new AnalysisCapabilityUnavailableError(active.route.binding?.identity.id ?? active.route.identity.id, operation, capability?.reason ?? "operation is not declared by this provider"));
     }
     const profile = active.profile !== null &&
-        (capability === undefined ||
-            capability.provider.id === active.profile.provider.id)
+        capability.provider.id === active.profile.provider.id
         ? active.profile
         : undefined;
     const cacheable = profile !== undefined &&

package/dist/application/binary/BinarySessionOpen.js

@@ -1,6 +1,6 @@
 import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../../domain/analysisSnapshot.js";
 import { parseBinaryTarget } from "../BinaryTargetResolver.js";
-import {} from "../../domain/binaryTarget.js";
+import {} from "../../domain/binaryTargetTypes.js";
 import { EvidenceIntegrityError, AnalysisSnapshotMismatchError, } from "../../domain/evidenceErrors.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { err } from "../../domain/result.js";
@@ -8,7 +8,15 @@ import { SessionProviderRouter } from "./SessionProviderRouter.js";
 /** Parse a target, resolve its provider route, and validate snapshot binding. */
 export const resolveSessionOpen = async (input) => {
     const { path, options } = input;
-    const parsed = await parseBinaryTarget(path, process.cwd(), process.arch, options.targetKind, options.formatHint);
+    const parsed = await parseBinaryTarget(path, {
+        ...(options.targetKind === undefined
+            ? {}
+            : { targetKind: options.targetKind }),
+        ...(options.formatHint === undefined
+            ? {}
+            : { formatHint: options.formatHint }),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    });
     if (!parsed.ok)
         return parsed;
     return resolveSessionTarget({ ...input, target: parsed.value });

package/dist/application/binary/BinarySessionRecords.js

@@ -6,7 +6,7 @@ import { err, ok } from "../../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { InvestigationRecords } from "../investigation/InvestigationRecords.js";
 const SNAPSHOT_MUTATION_RECOVERY = "Export session observations through export_evidence_bundle if needed. Close the active target without saving a snapshot, then reopen it before importing or saving a snapshot.";
-/** Binary snapshot owner and compatibility facade for composed investigation records. */
+/** Own binary snapshots and coordinate the composed investigation records. */
 export class BinarySessionRecords {
     #records;
     #snapshot = new AnalysisSnapshotCache();

package/dist/application/binary/BinarySessionStatus.js

@@ -1,9 +1,6 @@
 /** Project internal provider routing state into the caller-visible session status. */
 export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, }) => {
-    const configuredProvider = router.configuredIdentity();
-    const provider = providerSummary(configuredProvider);
-    const providers = router.providerIdentities(route).map(providerSummary);
-    const capabilities = [...(route.capabilities?.values() ?? [])]
+    const capabilities = [...route.capabilities.values()]
         .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => left.operation.localeCompare(right.operation))
         .map((descriptor) => {
@@ -38,8 +35,6 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
             .map(capabilityStatus),
     }));
     const common = {
-        provider,
-        providers,
         capabilities,
         analysis_provider_binding: analysisProviderBinding,
         analysis_provider_candidates: analysisProviderCandidates,