rea-agents 3.0.0 → 3.2.0

package/dist/application/ArtifactInventory/scanReader.js

@@ -3,16 +3,15 @@ import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
 import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "../ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-import { hashReadable, preflightEntry } from "./hash.js";
+import { hashReadable } from "./hash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
 const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradictions: [] });
-export const scanReader = async (reader, limits, signal, integrity = STRICT_INTEGRITY_POLICY) => {
+export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_POLICY) => {
     const { nodes, occurrences, pendingContradictions } = emptyScan();
     if (reader === undefined)
         return { nodes, occurrences, pendingContradictions };
     const context = {
         reader,
-        limits,
         signal,
         integrity,
         nodes,
@@ -20,65 +19,93 @@ export const scanReader = async (reader, limits, signal, integrity = STRICT_INTE
         pendingContradictions,
         occurrenceByPath: new Map(),
         registry: new ArtifactPathRegistry(),
-        totalBytes: 0,
     };
     await visitArtifactEntries(context, reader, "");
     return { nodes, occurrences, pendingContradictions };
 };
 const visitArtifactEntries = async (context, currentReader, prefix) => {
-    for await (const entry of currentReader.entries(context.signal)) {
-        if (context.occurrences.length >= context.limits.maxEntries)
-            throw new ArtifactReaderFailure("limit", "Artifact entry limit exceeded");
-        const logicalPath = normalizeArtifactPath(prefix.length === 0 ? entry.path : `${prefix}/${entry.path}`, context.limits);
-        const expandableAsar = isExpandableAsar(entry, logicalPath);
-        context.registry.add(logicalPath, expandableAsar ? "directory" : entry.kind);
-        preflightEntry(entry, context.limits);
-        const parent = nearestParent(logicalPath, context.occurrenceByPath);
-        const occurrence = createOccurrence(entry, logicalPath, parent?.occurrence_id ?? null);
-        let digested;
-        try {
-            digested = await digestArtifactEntry(context, currentReader, entry, logicalPath);
-        }
-        catch (cause) {
-            if (!isUnavailableUnpackedEntry(cause, entry))
-                throw cause;
-            occurrence.hash_status = "unavailable";
-            occurrence.limitations.push(UNAVAILABLE_UNPACKED_LIMITATION);
-        }
-        if (digested !== undefined) {
-            context.nodes.set(digested.node.artifact_id, digested.node);
-            occurrence.artifact_id = digested.node.artifact_id;
-            occurrence.hash_status = digested.mismatched ? "mismatched" : "verified";
-            if (digested.mismatched)
-                occurrence.limitations.push("Declared integrity metadata contradicts observed bytes.");
+    const stack = [
+        {
+            reader: currentReader,
+            prefix,
+            iterator: currentReader.entries(context.signal)[Symbol.asyncIterator](),
+            owned: false,
+        },
+    ];
+    try {
+        while (stack.length > 0) {
+            const frame = stack.at(-1);
+            if (frame === undefined)
+                break;
+            const next = await frame.iterator.next();
+            if (next.done) {
+                stack.pop();
+                if (frame.owned)
+                    await frame.reader.close();
+                continue;
+            }
+            const entry = next.value;
+            const logicalPath = normalizeArtifactPath(frame.prefix.length === 0
+                ? entry.path
+                : `${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);
+            let digested;
+            try {
+                digested = await digestArtifactEntry(context, frame.reader, entry, logicalPath);
+            }
+            catch (cause) {
+                if (!isUnavailableUnpackedEntry(cause, entry))
+                    throw cause;
+                occurrence.hash_status = "unavailable";
+                occurrence.limitations.push(UNAVAILABLE_UNPACKED_LIMITATION);
+            }
+            if (digested !== undefined) {
+                context.nodes.set(digested.node.artifact_id, digested.node);
+                occurrence.artifact_id = digested.node.artifact_id;
+                occurrence.hash_status = digested.mismatched
+                    ? "mismatched"
+                    : "verified";
+                if (digested.mismatched)
+                    occurrence.limitations.push("Declared integrity metadata contradicts observed bytes.");
+            }
+            context.occurrences.push(occurrence);
+            context.occurrenceByPath.set(logicalPath, occurrence);
+            if (expandableAsar && digested?.mismatched !== true) {
+                const nested = new AsarArtifactReader(entry.adapterKey);
+                stack.push({
+                    reader: nested,
+                    prefix: logicalPath,
+                    iterator: nested.entries(context.signal)[Symbol.asyncIterator](),
+                    owned: true,
+                });
+            }
         }
-        context.occurrences.push(occurrence);
-        context.occurrenceByPath.set(logicalPath, occurrence);
-        if (expandableAsar && digested?.mismatched !== true)
-            await visitNestedAsar(context, entry.adapterKey, logicalPath);
+    }
+    finally {
+        await Promise.allSettled(stack
+            .filter(({ owned }) => owned)
+            .map(async ({ reader, iterator }) => {
+            await iterator.return?.();
+            await reader.close();
+        }));
     }
 };
 const digestArtifactEntry = async (context, currentReader, entry, logicalPath) => {
     if ((entry.kind !== "file" && entry.kind !== "slice") || entry.encrypted)
         return undefined;
-    const remainingBytes = context.limits.maxTotalBytes - context.totalBytes;
-    if (remainingBytes <= 0)
-        throw new ArtifactReaderFailure("limit", "Artifact total byte limit exceeded");
-    if (entry.declaredSize !== null && entry.declaredSize > remainingBytes)
-        throw new ArtifactReaderFailure("limit", "Declared artifact bytes exceed remaining cumulative limit");
-    const digest = await hashReadable(await currentReader.open(entry, context.signal), Math.min(context.limits.maxEntryBytes, remainingBytes), context.signal);
-    context.totalBytes += digest.bytes;
+    const digest = await hashReadable(await currentReader.open(entry, context.signal), context.signal);
     const mismatched = entry.declaredSha256 !== null && entry.declaredSha256 !== digest.sha256;
-    if (mismatched && context.integrity.mode === "fail")
-        throw new ArtifactReaderFailure("integrity", `Artifact integrity metadata disagrees with content: ${logicalPath}`, undefined, {
-            logicalPath,
-            declaredSha256: entry.declaredSha256,
-            calculatedSha256: digest.sha256,
-            unpacked: entry.unpacked,
-        });
     if (mismatched && entry.declaredSha256 !== null) {
-        if (context.pendingContradictions.length >= context.integrity.maxMismatches)
-            throw new ArtifactReaderFailure("limit", "Artifact integrity mismatch limit exceeded");
+        if (context.integrity.mode === "fail")
+            throw new ArtifactReaderFailure("integrity", `Artifact integrity metadata disagrees with content: ${logicalPath}`, undefined, {
+                logicalPath,
+                declaredSha256: entry.declaredSha256,
+                calculatedSha256: digest.sha256,
+                unpacked: entry.unpacked,
+            });
         context.pendingContradictions.push({
             logicalPath,
             declaredSha256: entry.declaredSha256,
@@ -107,15 +134,6 @@ const digestArtifactEntry = async (context, currentReader, entry, logicalPath) =
         mismatched,
     };
 };
-const visitNestedAsar = async (context, adapterKey, logicalPath) => {
-    const nested = new AsarArtifactReader(adapterKey);
-    try {
-        await visitArtifactEntries(context, nested, logicalPath);
-    }
-    finally {
-        await nested.close();
-    }
-};
 const isExpandableAsar = (entry, logicalPath) => entry.kind === "file" &&
     logicalPath.toLowerCase().endsWith(".asar") &&
     entry.adapterKey.startsWith("/");

package/dist/application/ArtifactInventory/types.js

@@ -1,10 +1,6 @@
 export const NATIVE_MOUNT_DISABLED = {
-    nativeMountApproved: false,
-    nativeMountEnabled: false,
+    status: "disabled",
 };
 export const STRICT_INTEGRITY_POLICY = {
     mode: "fail",
-    approved: false,
-    enabled: false,
-    maxMismatches: 1,
 };

package/dist/application/ArtifactInventory.js

@@ -1,24 +1,16 @@
 import { realpath } from "node:fs/promises";
 import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { pageOf } from "./ArtifactGraphConstruction.js";
 import { abortIfNeeded } from "./ArtifactInventory/hash.js";
 import { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
 export { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
-/** Inventory one local artifact without extracting or mounting it. */
-export const inventoryArtifact = async (inputPath, limits, page, options = {}) => {
-    const snapshot = await scanArtifactInventory(inputPath, limits, options);
-    return paginateArtifactInventory(snapshot, page);
+/** Inventory one local artifact and return every graph collection inline. */
+export const inventoryArtifact = async (inputPath, options = {}) => {
+    const snapshot = await scanArtifactInventory(inputPath, options);
+    return artifactInventoryResultSchema.parse(snapshot);
 };
 /** Scan an artifact once and retain the complete immutable graph for projection. */
-export const scanArtifactInventory = async (inputPath, limits, options = {}) => {
+export const scanArtifactInventory = async (inputPath, options = {}) => {
     abortIfNeeded(options.signal);
     const path = await realpath(inputPath);
-    return scanCanonicalArtifactInventory(path, limits, options);
+    return scanCanonicalArtifactInventory(path, options);
 };
-/** Project independently paged graph collections from one inventory snapshot. */
-export const paginateArtifactInventory = (snapshot, page) => artifactInventoryResultSchema.parse({
-    ...snapshot,
-    nodes: pageOf(snapshot.nodes, page.nodeOffset, page.nodeLimit),
-    occurrences: pageOf(snapshot.occurrences, page.occurrenceOffset, page.occurrenceLimit),
-    edges: pageOf(snapshot.edges, page.edgeOffset, page.edgeLimit),
-});

package/dist/application/AuthorizedArtifactInventory.js

@@ -1,17 +1,7 @@
 import { realpath } from "node:fs/promises";
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
-import { withinRoot } from "../reference/ReferenceSourceReaderPaths.js";
 import { scanCanonicalArtifactInventory, } from "./ArtifactInventory.js";
-import { canonicalizeConfiguredRoots } from "./ConfiguredRoots.js";
 /** Resolve, authorize, and scan one artifact without a second path resolution. */
-export const scanAuthorizedArtifactInventory = async (inputPath, roots, limits, options = {}) => {
-    if (roots.length === 0)
-        throw new ArtifactReaderFailure("path", "Artifact input roots are disabled");
-    const [path, approved] = await Promise.all([
-        realpath(inputPath),
-        canonicalizeConfiguredRoots(roots),
-    ]);
-    if (!approved.some((root) => withinRoot(root, path)))
-        throw new ArtifactReaderFailure("path", "Artifact path is outside approved input roots");
-    return scanCanonicalArtifactInventory(path, limits, options);
+export const scanAuthorizedArtifactInventory = async (inputPath, options = {}) => {
+    const path = await realpath(inputPath);
+    return scanCanonicalArtifactInventory(path, options);
 };

package/dist/application/BinarySession.js

@@ -19,20 +19,15 @@ const ENHANCED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind })
  * of retaining a client whose resources were already shut down.
  */
 export class BinarySession extends BinarySessionRecords {
-    provider;
     #active;
     #transition = Promise.resolve();
     #calls = new Set();
     #providerRouter;
-    #runtimeAvailability = new Map();
+    #runtimeUnavailability = new Map();
     #availabilityListeners = new Set();
-    constructor(provider, options = {}) {
+    constructor(providerRouter) {
         super();
-        this.provider = provider;
-        this.#providerRouter =
-            provider instanceof SessionProviderRouter
-                ? provider
-                : SessionProviderRouter.legacy(provider, options);
+        this.#providerRouter = providerRouter;
     }
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
@@ -173,7 +168,14 @@ export class BinarySession extends BinarySessionRecords {
             await this.#drainCalls();
             const closed = previous === undefined
                 ? ok(null)
-                : await closeAnalysisClient(previous.client, previous.route.identity.id, options);
+                : await closeAnalysisClient(previous.client, previous.route.identity.id, {
+                    ...(options.progress === undefined
+                        ? {}
+                        : { progress: options.progress }),
+                    ...(options.retainProviderDocuments === true
+                        ? { retainDocument: true }
+                        : {}),
+                });
             this.clearSessionRecords();
             this.#clearRuntimeAvailability();
             return closed;
@@ -185,7 +187,7 @@ export class BinarySession extends BinarySessionRecords {
             target: this.#active?.target,
             route: this.#currentRoute(),
             router: this.#providerRouter,
-            runtimeAvailability: this.#runtimeAvailability,
+            runtimeUnavailability: this.#runtimeUnavailability,
             runId: this.#active?.runId,
             runtimeLineageSnapshots: this.#active?.client.runtimeLineageSnapshots?.() ?? [],
             requestActivitySnapshots: this.#active?.client.requestActivitySnapshots?.() ?? [],
@@ -214,7 +216,9 @@ export class BinarySession extends BinarySessionRecords {
             operation: name,
             parameters: arguments_,
             unboundOperationError: (operation, route) => this.#providerRouter.unboundOperationError(operation, route),
-            lookupSnapshot: (target, profile, operation, parameters) => this.lookupSnapshot(target, profile, operation, parameters),
+            lookupSnapshot: (target, profile, operation, parameters) => operation === "decode_interface_builder"
+                ? undefined
+                : this.lookupSnapshot(target, profile, operation, parameters),
         });
         if (!prepared.ok)
             return prepared;
@@ -225,9 +229,12 @@ export class BinarySession extends BinarySessionRecords {
         this.#calls.add(call);
         try {
             const result = await call;
-            const profiled = commitExecutionProfile(name, result, profile);
+            const profiled = bindExecutionTarget(commitExecutionProfile(name, result, profile), name, active.target);
             this.#observeRuntimeAvailability(name, profiled);
-            if (profiled.ok && cacheable && profile !== undefined)
+            if (profiled.ok &&
+                cacheable &&
+                profile !== undefined &&
+                name !== "decode_interface_builder")
                 this.recordSnapshot({
                     target: active.target,
                     profile,
@@ -246,12 +253,12 @@ export class BinarySession extends BinarySessionRecords {
     }
     #observeRuntimeAvailability(operation, result) {
         if (result.ok) {
-            if (this.#setRuntimeAvailability(operation, true, null))
+            if (this.#markRuntimeAvailable(operation))
                 this.#emitAvailabilityChanged();
             return;
         }
         if (result.error._tag === "AnalysisCapabilityUnavailableError") {
-            if (this.#setRuntimeAvailability(operation, false, result.error.message))
+            if (this.#markRuntimeUnavailable(operation, result.error.message))
                 this.#emitAvailabilityChanged();
             return;
         }
@@ -259,7 +266,6 @@ export class BinarySession extends BinarySessionRecords {
             "ProviderAdapterError",
             "HopperProcessError",
             "HopperStartError",
-            "HopperRemoteError",
         ].includes(result.error._tag)) {
             const capabilities = this.#active?.route.capabilities;
             const providerId = capabilities?.get(operation)?.provider.id;
@@ -267,27 +273,25 @@ export class BinarySession extends BinarySessionRecords {
             for (const descriptor of capabilities?.values() ?? [])
                 if (providerId !== undefined && descriptor.provider.id === providerId)
                     changed =
-                        this.#setRuntimeAvailability(descriptor.operation, false, "Provider became unavailable during this session.") || changed;
+                        this.#markRuntimeUnavailable(descriptor.operation, `${result.error._tag}: ${result.error.message}`) || changed;
             if (changed)
                 this.#emitAvailabilityChanged();
         }
     }
-    #setRuntimeAvailability(operation, available, reason) {
-        const current = this.#runtimeAvailability.get(operation);
-        if (current?.available === available && current.reason === reason)
-            return false;
-        if (available && current === undefined)
+    #markRuntimeAvailable(operation) {
+        return this.#runtimeUnavailability.delete(operation);
+    }
+    #markRuntimeUnavailable(operation, reason) {
+        const current = this.#runtimeUnavailability.get(operation);
+        if (current?.reason === reason)
             return false;
-        if (available)
-            this.#runtimeAvailability.delete(operation);
-        else
-            this.#runtimeAvailability.set(operation, { available, reason });
+        this.#runtimeUnavailability.set(operation, { reason });
         return true;
     }
     #clearRuntimeAvailability() {
-        if (this.#runtimeAvailability.size === 0)
+        if (this.#runtimeUnavailability.size === 0)
             return;
-        this.#runtimeAvailability.clear();
+        this.#runtimeUnavailability.clear();
         this.#emitAvailabilityChanged();
     }
     #emitAvailabilityChanged() {
@@ -372,3 +376,25 @@ const commitExecutionProfile = (operation, result, profile) => {
         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/BinarySessionComposition.js

@@ -1,9 +1,6 @@
 import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
 import { BinarySession } from "./BinarySession.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";
-const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrResolver === "function"
-    ? { resolveAnalysisProfile: optionsOrResolver }
-    : (optionsOrResolver ?? {});
 /**
  * Compose one provider-neutral session from deep-provider selection and
  * disjoint auxiliary operation families.
@@ -11,11 +8,3 @@ const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrRes
 export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
     ? registry
     : SessionProviderRouter.selectable(registry, auxiliaryProviders));
-/**
- * Compose a session through the same internal seam for focused adapter tests.
- * The constructor remains private to this composition module, so callers test
- * provider behavior without coupling to BinarySession construction.
- */
-export const composeBinarySessionFromFactory = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));
-/** Compose a focused session from any provider-shaped test seam. */
-export const composeBinarySessionFromProvider = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));

package/dist/application/BinarySessionOpen.js

@@ -1,5 +1,6 @@
 import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../domain/analysisSnapshot.js";
-import { parseBinaryTarget, } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
+import {} from "../domain/binaryTarget.js";
 import { EvidenceIntegrityError, } from "../domain/errors.js";
 import { err } from "../domain/result.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";

package/dist/application/BinarySessionRecords.js

@@ -1,25 +1,14 @@
 import { createEvidence } from "../domain/evidence.js";
-import { evidenceBundleForTarget, serializeEvidenceBundle, } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError, EvidenceLimitError, } from "../domain/errors.js";
-import { parseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
-import { parseReconstructionCoverageWorkspace, } from "../domain/reconstructionCoverage.js";
+import { evidenceBundleForTarget } from "../domain/evidenceBundle.js";
+import { EvidenceIntegrityError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { EvidenceLedger } from "./EvidenceLedger.js";
 import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
-/** Owns session evidence, snapshots, workspaces, and residual unknowns. */
+/** Owns session evidence, snapshots, and residual unknowns. */
 export class BinarySessionRecords {
-    static MAX_RETAINED_BUNDLES = 16;
-    static MAX_RETAINED_BUNDLE_BYTES = 64 * 1024 * 1024;
-    #evidence = new EvidenceLedger({
-        maxRecords: 10_000,
-        maxBytes: 64 * 1024 * 1024,
-    });
+    #evidence = new EvidenceLedger();
     #snapshot = new AnalysisSnapshotCache();
-    #retainedBundles = new Map();
-    #retainedBundleBytes = 0;
-    #investigationWorkspaces = new Map();
-    #coverageWorkspaces = new Map();
     #snapshotInvalidated = false;
     #snapshotListeners = new Set();
     /** Observe changes to the mutable current analysis snapshot resource. */
@@ -42,38 +31,13 @@ export class BinarySessionRecords {
     exportEvidenceBundle() {
         return this.#evidence.export();
     }
-    snapshotEvidenceBundle() {
-        const bundle = this.#evidence.export();
-        const encoded = serializeEvidenceBundle(bundle);
-        const digest = createHash("sha256").update(encoded).digest("hex");
-        const existing = this.#retainedBundles.get(digest);
-        if (existing === undefined) {
-            if (this.#retainedBundles.size >= BinarySessionRecords.MAX_RETAINED_BUNDLES)
-                return err(new EvidenceLimitError("records", BinarySessionRecords.MAX_RETAINED_BUNDLES));
-            const bytes = Buffer.byteLength(encoded);
-            if (this.#retainedBundleBytes + bytes >
-                BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES)
-                return err(new EvidenceLimitError("bytes", BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES));
-            this.#retainedBundles.set(digest, encoded);
-            this.#retainedBundleBytes += bytes;
-        }
-        return ok({
-            bundleDigest: digest,
-            bundleVersion: 2,
-            bytes: Buffer.byteLength(existing ?? encoded),
-            records: bundle.records.length,
-            unknowns: bundle.unknowns.length,
-            uri: `rea://evidence-bundle/${digest}`,
-        });
-    }
-    retainedEvidenceBundle(digest) {
-        return this.#retainedBundles.get(digest);
-    }
     importEvidenceBundle(bundle) {
         const imported = this.#evidence.import(bundle);
-        if (imported.ok && imported.value > 0)
+        if (!imported.ok)
+            return imported;
+        if (imported.value.changed)
             this.#emitSnapshotChanged();
-        return imported;
+        return ok(imported.value.recordsAdded);
     }
     exportAnalysisSnapshot() {
         const active = this.activeAnalysisBinding();
@@ -93,7 +57,10 @@ export class BinarySessionRecords {
             return err(new EvidenceIntegrityError("Analysis snapshot profile_mismatch: the active target has no concrete analysis profile"));
         const imported = this.#snapshot.import(snapshot, active === undefined
             ? undefined
-            : { target: active.target, profile: active.profile }, (bundle) => this.#evidence.import(bundle));
+            : { target: active.target, profile: active.profile }, (bundle) => {
+            const imported = this.#evidence.import(bundle);
+            return imported.ok ? ok(imported.value.recordsAdded) : imported;
+        });
         if (imported.ok)
             this.#emitSnapshotChanged();
         return imported;
@@ -131,43 +98,20 @@ export class BinarySessionRecords {
         this.#evidence.clear();
         this.#snapshot.clear();
         this.#snapshotInvalidated = false;
-        this.#retainedBundles.clear();
-        this.#retainedBundleBytes = 0;
         this.#emitSnapshotChanged();
     }
     #emitSnapshotChanged() {
-        for (const listener of this.#snapshotListeners)
-            void listener();
-    }
-    retainInvestigationWorkspace(workspace) {
-        const parsed = parseInvestigationWorkspace(workspace);
-        const key = workspaceKey(parsed.workspace_id, parsed.revision);
-        if (this.#investigationWorkspaces.has(key))
-            return "duplicate";
-        this.#investigationWorkspaces.set(key, parsed);
-        return "added";
-    }
-    investigationWorkspace(workspaceId, revision) {
-        const workspace = this.#investigationWorkspaces.get(workspaceKey(workspaceId, revision));
-        return workspace === undefined ? undefined : structuredClone(workspace);
-    }
-    investigationWorkspaces() {
-        return sortedWorkspaces(this.#investigationWorkspaces.values());
-    }
-    retainReconstructionCoverageWorkspace(workspace) {
-        const parsed = parseReconstructionCoverageWorkspace(workspace);
-        const key = workspaceKey(parsed.workspace_id, parsed.revision);
-        if (this.#coverageWorkspaces.has(key))
-            return "duplicate";
-        this.#coverageWorkspaces.set(key, parsed);
-        return "added";
-    }
-    reconstructionCoverageWorkspace(workspaceId, revision) {
-        const workspace = this.#coverageWorkspaces.get(workspaceKey(workspaceId, revision));
-        return workspace === undefined ? undefined : structuredClone(workspace);
-    }
-    reconstructionCoverageWorkspaces() {
-        return sortedWorkspaces(this.#coverageWorkspaces.values());
+        for (const listener of this.#snapshotListeners) {
+            try {
+                const notification = listener();
+                if (notification !== undefined)
+                    void notification.catch(() => undefined);
+            }
+            catch {
+                // External resource observers are best-effort; one callback must not
+                // make a committed evidence mutation appear to fail.
+            }
+        }
     }
     recordUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
@@ -185,7 +129,7 @@ export class BinarySessionRecords {
     updateUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
         const evidence = createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
-            predicateType: "rea.residual-unknown-mutation/v1",
+            predicateType: "rea.residual-unknown-mutation",
             operation: "update_unknown",
             parameters: {
                 unknown_id: input.unknown_id,
@@ -211,9 +155,3 @@ export class BinarySessionRecords {
         return this.#evidence.verifyUnknownResolution(unknownId);
     }
 }
-const workspaceKey = (workspaceId, revision) => `${workspaceId}:${String(revision)}`;
-const sortedWorkspaces = (workspaces) => [...workspaces]
-    .sort((left, right) => left.workspace_id.localeCompare(right.workspace_id) ||
-    left.revision - right.revision)
-    .map((workspace) => structuredClone(workspace));
-import { createHash } from "node:crypto";