rea-agents 3.2.0 → 4.0.0

package/dist/application/AppleAssetCatalogAnalysis.js

@@ -0,0 +1,171 @@
+import { createHash } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { analyzeInterfaceBuilderBundle } from "./InterfaceBuilderAnalysis.js";
+import { appleAssetCatalogInputSchema, parseAppleAssetCatalogRecords, projectAppleAssetCatalogPage, } from "../domain/appleAssetCatalog.js";
+import { execFileOutput } from "../process/ExecFileOutput.js";
+const ASSETUTIL = "/usr/bin/assetutil";
+const MAX_CATALOG_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_METADATA_BYTES = 64 * 1024 * 1024;
+const RESOURCE_KEY_FIELDS = new Set([
+    "image",
+    "imageName",
+    "image_name",
+    "resourceName",
+    "resource_name",
+    "assetName",
+    "asset_name",
+    "UIImageName",
+    "NSImageName",
+]);
+/** Inspect compiled asset catalog metadata without extracting rendition bytes. */
+export const analyzeAppleAssetCatalogs = async (input) => {
+    if (process.platform !== "darwin" && input.runAssetUtil === undefined)
+        throw new ArtifactReaderFailure("unavailable", "Apple asset catalog inspection requires macOS assetutil");
+    const page = appleAssetCatalogInputSchema.parse(input.page ?? {});
+    const reader = new DirectoryArtifactReader(input.bundlePath);
+    const catalogs = [];
+    let totalMetadataBytes = 0;
+    try {
+        for await (const entry of reader.entries(input.signal)) {
+            if (entry.kind !== "file" || !entry.path.endsWith("Assets.car"))
+                continue;
+            const inspected = await inspectAssetCatalogEntry({
+                reader,
+                entry,
+                runAssetUtil: input.runAssetUtil ?? runAssetUtil,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            totalMetadataBytes += inspected.metadataBytes;
+            if (totalMetadataBytes > MAX_TOTAL_METADATA_BYTES)
+                throw new ArtifactReaderFailure("limit", `Combined asset catalog metadata exceeds ${MAX_TOTAL_METADATA_BYTES} bytes`);
+            catalogs.push(inspected.catalog);
+        }
+    }
+    finally {
+        await reader.close();
+    }
+    if (catalogs.length === 0)
+        throw new ArtifactReaderFailure("unavailable", "No compiled Assets.car catalogs were found in the app bundle");
+    const interfaceBuilder = await analyzeInterfaceBuilderBundle({
+        bundlePath: input.bundlePath,
+        targetSha256: input.targetSha256,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    const resourceReferences = collectInterfaceBuilderResourceKeys(interfaceBuilder.graph.nodes);
+    const result = projectAppleAssetCatalogPage({
+        targetSha256: input.targetSha256,
+        catalogs,
+        offset: page.offset,
+        limit: page.limit,
+        resourceReferences,
+    });
+    return {
+        ...result,
+        limitations: [
+            ...result.limitations,
+            "Exact resource-key joins use only recognized image or asset key fields on decoded Interface Builder resource objects; other archive resource references are not inferred.",
+            ...(interfaceBuilder.graph.truncated
+                ? [
+                    "Interface Builder resource-key joins may be incomplete because the decoded UI graph was truncated.",
+                ]
+                : []),
+        ],
+    };
+};
+const inspectAssetCatalogEntry = async (input) => {
+    const { entry, reader, signal } = input;
+    const sha256 = await digestBounded(reader, entry, signal);
+    const before = await lstat(entry.adapterKey);
+    if (entry.sourceIdentity === undefined ||
+        before.dev !== entry.sourceIdentity.device ||
+        before.ino !== entry.sourceIdentity.inode)
+        throw new ArtifactReaderFailure("integrity", `Asset catalog changed before inspection: ${entry.path}`);
+    const output = await input.runAssetUtil(entry.adapterKey, signal);
+    const after = await lstat(entry.adapterKey);
+    if (before.dev !== after.dev ||
+        before.ino !== after.ino ||
+        before.size !== after.size ||
+        (await digestBounded(reader, entry, signal)) !== sha256)
+        throw new ArtifactReaderFailure("integrity", `Asset catalog changed during inspection: ${entry.path}`);
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch (cause) {
+        throw new ArtifactReaderFailure("format", `assetutil returned invalid JSON for ${entry.path}`, { cause });
+    }
+    try {
+        return {
+            catalog: {
+                path: entry.path,
+                sha256,
+                records: parseAppleAssetCatalogRecords(parsed),
+            },
+            metadataBytes: Buffer.byteLength(output, "utf8"),
+        };
+    }
+    catch (cause) {
+        throw new ArtifactReaderFailure("format", `assetutil returned an unsupported record for ${entry.path}`, { cause });
+    }
+};
+/** Return only explicit image or asset fields from decoded resource objects. */
+export const collectInterfaceBuilderResourceKeys = (nodes) => nodes.flatMap((node) => {
+    const source = node.evidence.find((item) => item.artifact_path !== null && item.artifact_sha256 !== null);
+    const sourcePath = source?.artifact_path;
+    const sourceArchiveSha256 = source?.artifact_sha256;
+    if (sourcePath == null || sourceArchiveSha256 == null)
+        return [];
+    return Object.entries(node.attributes).flatMap(([field, value]) => RESOURCE_KEY_FIELDS.has(field) &&
+        typeof value === "string" &&
+        value.length > 0
+        ? [
+            {
+                sourceNodeId: node.id,
+                sourcePath,
+                sourceArchiveSha256,
+                field,
+                key: value,
+            },
+        ]
+        : []);
+});
+const runAssetUtil = async (path, signal) => {
+    try {
+        return (await execFileOutput(ASSETUTIL, ["--info", path], {
+            timeout: 60_000,
+            maxBuffer: MAX_CATALOG_BYTES,
+            ...(signal === undefined ? {} : { signal }),
+        })).stdout;
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw new ArtifactReaderFailure("cancelled", "Asset catalog inspection cancelled");
+        const code = typeof cause === "object" && cause !== null && "code" in cause
+            ? cause.code
+            : undefined;
+        throw new ArtifactReaderFailure(code === "ENOENT"
+            ? "unavailable"
+            : code === "ETIMEDOUT" || code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
+                ? "limit"
+                : "io", `assetutil failed${code === undefined ? "" : ` (${String(code)})`}`, { cause });
+    }
+};
+const digestBounded = async (reader, entry, signal) => {
+    if (entry.declaredSize === null || entry.declaredSize > MAX_CATALOG_BYTES)
+        throw new ArtifactReaderFailure("limit", `Asset catalog exceeds ${MAX_CATALOG_BYTES} bytes: ${entry.path}`);
+    const stream = await reader.open(entry, signal);
+    const hash = createHash("sha256");
+    let length = 0;
+    for await (const chunk of stream) {
+        if (signal?.aborted === true)
+            throw new ArtifactReaderFailure("cancelled", "Asset catalog inspection cancelled");
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        length += bytes.length;
+        if (length > MAX_CATALOG_BYTES)
+            throw new ArtifactReaderFailure("limit", `Asset catalog exceeds byte limit: ${entry.path}`);
+        hash.update(bytes);
+    }
+    return hash.digest("hex");
+};

package/dist/application/ArtifactExtractionDestination.js

@@ -3,15 +3,3 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 /** Choose a fresh temporary destination for an artifact extraction. */
 export const createArtifactExtractionDestination = () => join(tmpdir(), `rea-extracted-${randomUUID()}`);
-/** Stable parent scope used to authorize REA-owned extraction destinations. */
-export const artifactExtractionPermissionRoot = () => tmpdir();
-/** Stable filesystem scope for the destination selected internally by REA. */
-export const artifactExtractionPermissionRequest = () => ({
-    capability: "artifact_extract",
-    roots: [artifactExtractionPermissionRoot()],
-    executables: [],
-    environment_names: [],
-    network: "none",
-    mount: false,
-    operation_identity: "extract_artifact:temporary_output",
-});

package/dist/application/ArtifactGraphConstruction.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { zipPackageFormatForPath } from "../domain/zipPackageFormat.js";
+import { mzWindowsHeaderOffset, parseDosMzHeader } from "../domain/dosMz.js";
 /** Index the first occurrence for each canonical logical path. */
 export const indexOccurrencesByPath = (occurrences) => {
     const byPath = new Map();
@@ -25,6 +26,15 @@ export const createOccurrence = (entry, path, parent) => ({
         : { offset: entry.byteOffset, length: entry.declaredSize },
     limitations: [...entry.limitations],
 });
+/** Preserve collation order and break distinct-name ties by UTF-16 code units. */
+export const compareDirectoryChildNames = (left, right) => {
+    const collated = left.localeCompare(right);
+    if (collated !== 0)
+        return collated;
+    if (left < right)
+        return -1;
+    return left > right ? 1 : 0;
+};
 export const materializeDirectoryNodes = (occurrences, nodes) => {
     const directories = occurrences
         .filter(({ entry_kind: kind }) => kind === "directory")
@@ -42,11 +52,12 @@ export const materializeDirectoryNodes = (occurrences, nodes) => {
     for (const directory of directories) {
         const children = (childrenByParent.get(directory.occurrence_id) ?? [])
             .map(({ logical_path, artifact_id, entry_kind }) => ({
-            name: logical_path.split("/").at(-1),
+            // Intermediate directory entries may be absent from an archive.
+            name: logical_path.slice(directory.logical_path.length + 1),
             artifact_id,
             entry_kind,
         }))
-            .sort((left, right) => String(left.name).localeCompare(String(right.name)));
+            .sort((left, right) => compareDirectoryChildNames(left.name, right.name));
         const node = createArtifactNode({
             sha256: digestCanonical({ kind: "directory", children }),
             size: 0,
@@ -76,7 +87,9 @@ export const createRootNode = (input) => createArtifactNode({
     kind: input.directory ||
         ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(input.format)
         ? "container"
-        : classifyArtifactPath(input.path).kind,
+        : input.format === "dos-mz"
+            ? "executable"
+            : classifyArtifactPath(input.path).kind,
     format: input.format,
     executable: false,
     contentState: "materialized",
@@ -156,12 +169,14 @@ export const createArtifactEdges = (rootArtifactId, occurrences, producer) => {
     }
     return edges;
 };
-export const nearestParent = (path, occurrences) => {
+export const nearestParent = (path, occurrences, expandedContainerIds) => {
     const parts = path.split("/");
     while (parts.length > 1) {
         parts.pop();
         const candidate = occurrences.get(parts.join("/"));
-        if (candidate?.entry_kind === "directory")
+        if (candidate !== undefined &&
+            (candidate.entry_kind === "directory" ||
+                expandedContainerIds.has(candidate.occurrence_id)))
             return candidate;
     }
     return undefined;
@@ -191,7 +206,7 @@ export const classifyArtifactPath = (path) => {
     return { kind: "resource", format: "file" };
 };
 /** Classify executable formats from bytes while retaining path-specific roles. */
-export const classifyArtifactContent = (path, prefix) => {
+export const classifyArtifactContent = (path, prefix, fileSize = prefix.length) => {
     const byPath = classifyArtifactPath(path);
     if (prefix.length >= 4) {
         const magic = prefix.readUInt32BE(0);
@@ -215,11 +230,29 @@ export const classifyArtifactContent = (path, prefix) => {
                 format: "elf",
             };
     }
-    if (prefix.length >= 2 && prefix[0] === 0x4d && prefix[1] === 0x5a)
-        return {
-            kind: byPath.kind === "native-addon" ? "native-addon" : "executable",
-            format: "pe",
-        };
+    if (prefix.length >= 2 && prefix[0] === 0x4d && prefix[1] === 0x5a) {
+        if (!Number.isSafeInteger(fileSize) ||
+            fileSize < prefix.length ||
+            prefix.length < Math.min(fileSize, 64))
+            return { kind: "unknown", format: "unknown" };
+        const windowsOffset = mzWindowsHeaderOffset(prefix);
+        if (windowsOffset !== null) {
+            if (windowsOffset >= 64 &&
+                windowsOffset <= prefix.length - 4 &&
+                prefix
+                    .subarray(windowsOffset, windowsOffset + 4)
+                    .equals(Buffer.from([0x50, 0x45, 0, 0])))
+                return {
+                    kind: byPath.kind === "native-addon" ? "native-addon" : "executable",
+                    format: "pe",
+                };
+        }
+        else if (parseDosMzHeader(prefix, fileSize).ok) {
+            return { kind: "executable", format: "dos-mz" };
+        }
+        // Missing bounded evidence and malformed MZ bytes both remain unclassified.
+        return { kind: "unknown", format: "unknown" };
+    }
     return byPath;
 };
 export const digestCanonical = (value) => {

package/dist/application/ArtifactInventory/classify.js

@@ -1,5 +1,6 @@
 import { open } from "node:fs/promises";
-import { classifyArtifactPath } from "../ArtifactGraphConstruction.js";
+import { classifyArtifactContent } from "../ArtifactGraphConstruction.js";
+import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "./hash.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();
@@ -19,24 +20,15 @@ export const classifyRoot = async (path, directory) => {
         return extensionFormat;
     const handle = await open(path, "r");
     try {
-        const magic = Buffer.alloc(4);
+        const magic = Buffer.alloc(ARTIFACT_CLASSIFICATION_PREFIX_BYTES);
         const observed = await handle.read(magic, 0, magic.length, 0);
-        if (hasZipSignature(magic.subarray(0, observed.bytesRead)))
+        const prefix = magic.subarray(0, observed.bytesRead);
+        if (hasZipSignature(prefix))
             return "zip";
-        if (observed.bytesRead === 4) {
-            const header = magic.readUInt32BE(0);
-            if ([0xcafebabe, 0xbebafeca, 0xcafebabf, 0xbfbafeca].includes(header))
-                return "mach-o-universal";
-            if ([0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe].includes(header))
-                return "mach-o";
-            if (magic.equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
-                return "elf";
-        }
-        if (observed.bytesRead >= 2 && magic[0] === 0x4d && magic[1] === 0x5a)
-            return "pe";
+        return classifyArtifactContent(path, prefix, (await handle.stat()).size)
+            .format;
     }
     finally {
         await handle.close();
     }
-    return classifyArtifactPath(path).format;
 };

package/dist/application/ArtifactInventory/hash.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { streamChunkToBuffer } from "../../artifacts/StreamBytes.js";
+/** Bounded classification evidence; this is not an executable format size limit. */
+export const ARTIFACT_CLASSIFICATION_PREFIX_BYTES = 8_192;
 export const abortIfNeeded = (signal) => {
     if (signal?.aborted === true)
         throw new ArtifactReaderFailure("cancelled", "Artifact inventory cancelled");
@@ -15,8 +17,8 @@ export const hashReadable = async (stream, signal) => {
         const chunk = streamChunkToBuffer(raw);
         bytes += chunk.length;
         hash.update(chunk);
-        if (prefixBytes < 16) {
-            const selected = chunk.subarray(0, 16 - prefixBytes);
+        if (prefixBytes < ARTIFACT_CLASSIFICATION_PREFIX_BYTES) {
+            const selected = chunk.subarray(0, ARTIFACT_CLASSIFICATION_PREFIX_BYTES - prefixBytes);
             prefixes.push(selected);
             prefixBytes += selected.length;
         }

package/dist/application/ArtifactInventory/policy.js

@@ -1,17 +1,2 @@
-import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
-/** Resolve caller approval and operator policy before native reader selection. */
-export const resolveNativeMountPolicy = (approved, enabled) => {
-    if (!approved)
-        return { status: "disabled" };
-    if (!enabled)
-        throw new ArtifactReaderFailure("unavailable", "Native DMG mounting is disabled by operator policy");
-    return { status: "approved" };
-};
-/** Resolve parsed caller intent and operator policy before artifact scanning. */
-export const resolveArtifactIntegrityPolicy = (intent, enabled) => {
-    if (intent.mode === "fail")
-        return intent;
-    if (!enabled)
-        throw new ArtifactReaderFailure("policy", "Integrity continuation requires explicit approval and operator policy");
-    return intent;
-};
+/** Preserve the explicit integrity admission choice without changing verification. */
+export const resolveArtifactIntegrityPolicy = (intent) => intent;

package/dist/application/ArtifactInventory/reader.js

@@ -3,7 +3,7 @@ import { DirectoryArtifactReader } from "../../artifacts/DirectoryArtifactReader
 import { MachOSliceArtifactReader } from "../../artifacts/MachOSliceArtifactReader.js";
 import { NativeDmgArtifactReader } from "../../artifacts/NativeDmgArtifactReader.js";
 import { ZipArtifactReader } from "../../artifacts/ZipArtifactReader.js";
-export const createReader = async (path, format, nativeMount, signal) => {
+export const createReader = async (path, format, signal) => {
     switch (format) {
         case "directory":
             return new DirectoryArtifactReader(path);
@@ -20,7 +20,7 @@ export const createReader = async (path, format, nativeMount, signal) => {
                 ? new MachOSliceArtifactReader(path)
                 : undefined;
         case "dmg":
-            if (nativeMount.status === "disabled")
+            if (process.platform !== "darwin")
                 return undefined;
             return NativeDmgArtifactReader.create(path, signal);
         default:
@@ -32,7 +32,7 @@ export const inventoryLimitations = (format, reader) => {
         return [];
     if (format === "dmg" || format === "pkg")
         return [
-            `${format.toUpperCase()} root hash is observed; child inventory requires an approved native macOS adapter.`,
+            `${format.toUpperCase()} root hash is observed; child inventory requires a native macOS adapter.`,
         ];
     if (format === "mach-o-universal" && process.platform !== "darwin")
         return ["Universal Mach-O slices require the native macOS lipo adapter."];

package/dist/application/ArtifactInventory/scanCanonical.js

@@ -7,7 +7,7 @@ import { classifyRoot } from "./classify.js";
 import { hashReadable } from "./hash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
-import { NATIVE_MOUNT_DISABLED, STRICT_INTEGRITY_POLICY, } from "./types.js";
+import { STRICT_INTEGRITY_POLICY, } from "./types.js";
 export const scanCanonicalArtifactInventory = async (path, options = {}) => {
     const integrity = options.integrity ?? STRICT_INTEGRITY_POLICY;
     const metadata = await lstat(path);
@@ -15,7 +15,7 @@ export const scanCanonicalArtifactInventory = async (path, options = {}) => {
     const rootDigest = metadata.isDirectory()
         ? null
         : await hashReadable(createReadStream(path), options.signal);
-    const reader = await createReader(path, rootFormat, options.nativeMount ?? NATIVE_MOUNT_DISABLED, options.signal);
+    const reader = await createReader(path, rootFormat, options.signal);
     try {
         const { nodes, occurrences, pendingContradictions } = await scanReader(reader, options.signal, integrity);
         return await buildInventorySnapshot({

package/dist/application/ArtifactInventory/scanReader.js

@@ -1,3 +1,4 @@
+import { isAbsolute } from "node:path";
 import { ArtifactPathRegistry, normalizeArtifactPath, } from "../../artifacts/ArtifactPaths.js";
 import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
@@ -19,8 +20,14 @@ export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_PO
         pendingContradictions,
         occurrenceByPath: new Map(),
         registry: new ArtifactPathRegistry(),
+        expandedContainerIds: new Set(),
     };
     await visitArtifactEntries(context, reader, "");
+    // Archive directories may appear after their children. Resolve containment
+    // against the complete index before directory identities are materialized.
+    for (const occurrence of occurrences)
+        occurrence.parent_occurrence_id =
+            nearestParent(occurrence.logical_path, context.occurrenceByPath, context.expandedContainerIds)?.occurrence_id ?? null;
     return { nodes, occurrences, pendingContradictions };
 };
 const visitArtifactEntries = async (context, currentReader, prefix) => {
@@ -50,8 +57,7 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
                 : `${frame.prefix}/${entry.path}`);
             const expandableAsar = isExpandableAsar(entry, logicalPath);
             context.registry.add(logicalPath, expandableAsar ? "directory" : entry.kind);
-            const parent = nearestParent(logicalPath, context.occurrenceByPath);
-            const occurrence = createOccurrence(entry, logicalPath, parent?.occurrence_id ?? null);
+            const occurrence = createOccurrence(entry, logicalPath, null);
             let digested;
             try {
                 digested = await digestArtifactEntry(context, frame.reader, entry, logicalPath);
@@ -75,6 +81,8 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
             context.occurrenceByPath.set(logicalPath, occurrence);
             if (expandableAsar && digested?.mismatched !== true) {
                 const nested = new AsarArtifactReader(entry.adapterKey);
+                // Only traversed containers can own members, not opaque ASAR-named files.
+                context.expandedContainerIds.add(occurrence.occurrence_id);
                 stack.push({
                     reader: nested,
                     prefix: logicalPath,
@@ -116,7 +124,7 @@ const digestArtifactEntry = async (context, currentReader, entry, logicalPath) =
     }
     const classified = entry.kind === "slice"
         ? { kind: "universal-slice", format: "mach-o" }
-        : classifyArtifactContent(logicalPath, digest.prefix);
+        : classifyArtifactContent(logicalPath, digest.prefix, digest.bytes);
     return {
         node: createArtifactNode({
             sha256: digest.sha256,
@@ -136,7 +144,7 @@ const digestArtifactEntry = async (context, currentReader, entry, logicalPath) =
 };
 const isExpandableAsar = (entry, logicalPath) => entry.kind === "file" &&
     logicalPath.toLowerCase().endsWith(".asar") &&
-    entry.adapterKey.startsWith("/");
+    isAbsolute(entry.adapterKey);
 const isUnavailableUnpackedEntry = (cause, entry) => entry.unpacked &&
     cause instanceof ArtifactReaderFailure &&
     cause.reason === "unavailable";

package/dist/application/ArtifactInventory/types.js

@@ -1,6 +1,3 @@
-export const NATIVE_MOUNT_DISABLED = {
-    status: "disabled",
-};
 export const STRICT_INTEGRITY_POLICY = {
     mode: "fail",
 };

package/dist/application/BinarySession.js

@@ -1,13 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { analysisProfilesEqual, } from "../domain/analysisProfile.js";
-import { AnalysisCancelledError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisCancelledError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
+import { createEvidence } from "../domain/evidence.js";
 import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { SessionProviderRouter, } from "./SessionProviderRouter.js";
 import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, } from "./BinarySessionOpen.js";
-import { prepareSessionExecution } from "./BinarySessionExecution.js";
+import { bindExecutionTarget, commitExecutionProfile, prepareSessionExecution, } from "./BinarySessionExecution.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy").map(({ name }) => name));
 const ENHANCED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "enhanced").map(({ name }) => name));
@@ -143,10 +144,12 @@ export class BinarySession extends BinarySessionRecords {
                 runId,
             };
             this.#clearRuntimeAvailability();
-            if (profile === null)
-                this.clearSnapshot();
-            else
-                this.selectSnapshot(target, profile);
+            if (options.snapshot === undefined) {
+                if (profile === null)
+                    this.clearSnapshot();
+                else
+                    this.selectSnapshot(target, profile);
+            }
             if (options.snapshot !== undefined) {
                 const imported = this.importAnalysisSnapshot(options.snapshot);
                 if (!imported.ok) {
@@ -216,7 +219,9 @@ export class BinarySession extends BinarySessionRecords {
             operation: name,
             parameters: arguments_,
             unboundOperationError: (operation, route) => this.#providerRouter.unboundOperationError(operation, route),
-            lookupSnapshot: (target, profile, operation, parameters) => operation === "decode_interface_builder"
+            lookupSnapshot: (target, profile, operation, parameters) => operation === "decode_interface_builder" ||
+                operation === "inspect_asset_catalog" ||
+                operation === "inspect_keyed_archive"
                 ? undefined
                 : this.lookupSnapshot(target, profile, operation, parameters),
         });
@@ -234,7 +239,21 @@ export class BinarySession extends BinarySessionRecords {
             if (profiled.ok &&
                 cacheable &&
                 profile !== undefined &&
-                name !== "decode_interface_builder")
+                name !== "decode_interface_builder" &&
+                name !== "inspect_asset_catalog" &&
+                name !== "inspect_keyed_archive") {
+                const evidence = createEvidence(profiled.value.subject ?? active.target, profiled.value.provider, {
+                    operation: name,
+                    parameters: arguments_,
+                    result: profiled.value.result,
+                    analysisProfile: profile,
+                    rawResult: profiled.value.rawResult,
+                    limitations: profiled.value.limitations,
+                    locations: profiled.value.locations,
+                });
+                const recorded = this.recordEvidence(evidence);
+                if (!recorded.ok)
+                    return recorded;
                 this.recordSnapshot({
                     target: active.target,
                     profile,
@@ -242,6 +261,7 @@ export class BinarySession extends BinarySessionRecords {
                     parameters: arguments_,
                     execution: profiled.value,
                 });
+            }
             else if (profiled.ok && capability?.effects.mutatesArtifact === true) {
                 this.invalidateSnapshot();
             }
@@ -363,38 +383,3 @@ export class BinarySession extends BinarySessionRecords {
     }
 }
 const isAborted = (signal) => signal?.aborted === true;
-const commitExecutionProfile = (operation, result, profile) => {
-    if (!result.ok || profile === undefined)
-        return result;
-    const provider = result.value.provider;
-    if (provider.id !== profile.provider.id ||
-        provider.name !== profile.provider.name ||
-        provider.version !== profile.provider.version)
-        return err(new ProviderAdapterError(profile.provider.id, `${operation}:profile`));
-    return ok({
-        ...result.value,
-        analysisProfile: structuredClone(profile),
-    });
-};
-const bindExecutionTarget = (result, operation, target) => {
-    if (!result.ok)
-        return result;
-    const subject = {
-        path: target.path,
-        sha256: target.sha256,
-        format: target.format === "analysis-database"
-            ? "analysis-database"
-            : target.format,
-        ...(target.architecture === undefined
-            ? {}
-            : { architecture: target.architecture }),
-    };
-    if (result.value.subject !== null &&
-        result.value.subject.sha256 !== target.sha256) {
-        if (!isArtifactInventorySubject(operation, result.value.subject, target))
-            return err(new ProviderAdapterError(result.value.provider.id, `${operation}:subject`));
-    }
-    return ok({ ...result.value, subject: result.value.subject ?? subject });
-};
-const isArtifactInventorySubject = (operation, subject, target) => (operation === "inventory_artifact" || operation === "inspect_artifact") &&
-    subject.path === (target.sourcePath ?? target.path);

package/dist/application/BinarySessionExecution.js

@@ -1,4 +1,4 @@
-import { AnalysisCapabilityUnavailableError, NoBinaryOpenError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, NoBinaryOpenError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { isSnapshotCacheable } from "./AnalysisSnapshotCache.js";
 /** Resolve capability, profile, and snapshot state before invoking a provider. */
@@ -26,3 +26,39 @@ export const prepareSessionExecution = (input) => {
         : undefined;
     return ok({ active, capability, profile, cacheable, cached });
 };
+/** Attach the selected profile only when the provider identity agrees. */
+export const commitExecutionProfile = (operation, result, profile) => {
+    if (!result.ok || profile === undefined)
+        return result;
+    const provider = result.value.provider;
+    if (provider.id !== profile.provider.id ||
+        provider.name !== profile.provider.name ||
+        provider.version !== profile.provider.version)
+        return err(new ProviderAdapterError(profile.provider.id, `${operation}:profile`));
+    return ok({
+        ...result.value,
+        analysisProfile: structuredClone(profile),
+    });
+};
+/** Bind an execution to the selected target, preserving valid artifact subjects. */
+export const bindExecutionTarget = (result, operation, target) => {
+    if (!result.ok)
+        return result;
+    const subject = {
+        path: target.path,
+        sha256: target.sha256,
+        format: target.format === "analysis-database"
+            ? "analysis-database"
+            : target.format,
+        ...(target.architecture === undefined
+            ? {}
+            : { architecture: target.architecture }),
+    };
+    if (result.value.subject !== null &&
+        result.value.subject.sha256 !== target.sha256 &&
+        !isArtifactInventorySubject(operation, result.value.subject, target))
+        return err(new ProviderAdapterError(result.value.provider.id, `${operation}:subject`));
+    return ok({ ...result.value, subject: result.value.subject ?? subject });
+};
+const isArtifactInventorySubject = (operation, subject, target) => (operation === "inventory_artifact" || operation === "inspect_artifact") &&
+    subject.path === (target.sourcePath ?? target.path);