rea-agents 6.5.0 → 6.7.0

package/dist/application/binary/BinarySession.js

@@ -11,7 +11,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 { closeAnalysisClient } from "../../providers/AnalysisClientCleanup.js";
 import { analysisErrorWithCleanupFailure } from "../../domain/analysisErrorCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => name));
@@ -118,8 +118,10 @@ export class BinarySession extends BinarySessionRecords {
             target,
             options,
             stagedSnapshotMatches: (target, profile) => this.matchesSnapshot(target, profile),
-        }).then((resolved) => isAborted(options.signal)
-            ? err(new AnalysisCancelledError("open_binary"))
+        }).then((resolved) => resolved.ok && isAborted(options.signal)
+            ? err(new AnalysisCancelledError("open_binary", {
+                cause: options.signal?.reason,
+            }))
             : resolved);
     }
     /**
@@ -127,11 +129,11 @@ export class BinarySession extends BinarySessionRecords {
      * Returns the switch failure even if best-effort restoration also fails.
      */
     open(path, options = {}) {
-        return this.#open(() => resolveSessionOpen({
+        return this.#open((admitted) => resolveSessionOpen({
             router: this.#providerRouter,
             current: this.#active,
             path,
-            options,
+            options: admitted,
             stagedSnapshotMatches: (target, profile) => this.matchesSnapshot(target, profile),
         }), options);
     }
@@ -145,7 +147,24 @@ export class BinarySession extends BinarySessionRecords {
         })), options);
     }
     #open(resolve, options) {
-        return this.#serialize((admittedThrough) => this.#openWithinTransition(admittedThrough, resolve, options));
+        return this.#serialize(async (admittedThrough) => {
+            const admitted = await this.#withLoadedSnapshot(options);
+            if (!admitted.ok)
+                return admitted;
+            return this.#openWithinTransition(admittedThrough, () => resolve(admitted.value), admitted.value);
+        });
+    }
+    /** Read the staged snapshot only after earlier lifecycle transitions have settled. */
+    async #withLoadedSnapshot(options) {
+        if (options.loadSnapshot === undefined)
+            return ok(options);
+        if (isAborted(options.signal))
+            return err(new AnalysisCancelledError("open_binary"));
+        const loaded = await options.loadSnapshot();
+        if (!loaded.ok)
+            return loaded;
+        const { loadSnapshot: _loaded, ...rest } = options;
+        return ok({ ...rest, snapshot: loaded.value });
     }
     async #openWithinTransition(admittedThrough, resolve, options) {
         if (this.#externalMutationCleanupFailure?.cleanupIncomplete === true)
@@ -180,7 +199,7 @@ export class BinarySession extends BinarySessionRecords {
         const previous = this.#active;
         this.#active = undefined;
         if (previous !== undefined) {
-            const closed = await this.#retireClient(previous.client, previous.route.identity.id);
+            const closed = await this.#retireClient(previous);
             if (!closed.ok) {
                 // A failed open retires the provider cache, not the investigation.
                 // Preserve Evidence and Unknown history for export and recovery.
@@ -192,20 +211,21 @@ export class BinarySession extends BinarySessionRecords {
         if (isAborted(options.signal))
             return err(await this.#restoreAfterFailedOpen(previous, new AnalysisCancelledError("open_binary")));
         const runId = randomUUID();
-        const client = route.createClient(target, { runId });
+        const client = route.createClient(target, {
+            runId,
+        });
+        const run = { client, route, runId };
         const started = await client.execute("health", {}, options);
         if (!started.ok) {
-            return err(await this.#failedOpen(client, route.identity.id, previous, started.error));
+            return err(await this.#failedOpen(run, previous, started.error));
         }
         if (isAborted(options.signal)) {
-            return err(await this.#failedOpen(client, route.identity.id, previous, new AnalysisCancelledError("open_binary")));
+            return err(await this.#failedOpen(run, previous, new AnalysisCancelledError("open_binary")));
         }
         this.#active = {
             target,
-            client,
             profile,
-            route,
-            runId,
+            ...run,
             nativeSourceAdmitted: false,
         };
         this.#clearRuntimeAvailability();
@@ -220,7 +240,7 @@ export class BinarySession extends BinarySessionRecords {
             const imported = this.importAnalysisSnapshot(options.snapshot);
             if (!imported.ok) {
                 this.#active = undefined;
-                return err(await this.#failedOpen(client, route.identity.id, previous, imported.error));
+                return err(await this.#failedOpen(run, previous, imported.error));
             }
         }
         return ok(target);
@@ -298,7 +318,7 @@ export class BinarySession extends BinarySessionRecords {
         this.#active = undefined;
         const closed = previous === undefined
             ? await this.#retryPendingCleanup(options.progress, options.retainProviderDocuments)
-            : await this.#retireClient(previous.client, previous.route.identity.id, {
+            : await this.#retireClient(previous, {
                 ...(options.progress === undefined
                     ? {}
                     : { progress: options.progress }),
@@ -310,14 +330,24 @@ export class BinarySession extends BinarySessionRecords {
             this.clearSessionRecords();
         this.#clearRuntimeAvailability();
         const fileResources = await this.closeWriteResources();
-        if (!closed.ok && !fileResources.ok)
-            return err(analysisErrorWithCleanupFailure(closed.error, fileResources.error, "close_binary"));
-        return closed.ok ? fileResources : closed;
+        const candidateResources = await this.#providerRouter.closeOwnedResources();
+        const resourceFailures = [
+            ...(fileResources.ok ? [] : [fileResources.error]),
+            ...(candidateResources.ok ? [] : [candidateResources.error]),
+        ];
+        let resourceFailure = resourceFailures[0];
+        for (const next of resourceFailures.slice(1))
+            if (resourceFailure !== undefined)
+                resourceFailure = analysisErrorWithCleanupFailure(resourceFailure, next, "close_binary");
+        if (!closed.ok && resourceFailure !== undefined)
+            return err(analysisErrorWithCleanupFailure(closed.error, resourceFailure, "close_binary"));
+        if (!closed.ok)
+            return closed;
+        return resourceFailure === undefined ? ok(null) : err(resourceFailure);
     }
-    async #retireClient(client, providerId, options = {}) {
+    async #retireClient(run, options = {}) {
         this.#pendingCleanup = {
-            client,
-            providerId,
+            run,
             retainDocument: options.retainDocument === true,
         };
         return this.#retryPendingCleanup(options.progress);
@@ -330,7 +360,7 @@ export class BinarySession extends BinarySessionRecords {
             pending = { ...pending, retainDocument };
             this.#pendingCleanup = pending;
         }
-        const closed = await closeAnalysisClient(pending.client, pending.providerId, {
+        const closed = await closeAnalysisClient(pending.run.client, pending.run.route.identity.id, {
             ...(progress === undefined ? {} : { progress }),
             ...(pending.retainDocument ? { retainDocument: true } : {}),
         });
@@ -338,8 +368,8 @@ export class BinarySession extends BinarySessionRecords {
             this.#pendingCleanup = undefined;
         return closed;
     }
-    async #failedOpen(client, providerId, previous, primary) {
-        const closed = await this.#retireClient(client, providerId);
+    async #failedOpen(run, previous, primary) {
+        const closed = await this.#retireClient(run);
         if (!closed.ok)
             return analysisErrorWithCleanupFailure(primary, closed.error, "open_binary");
         return this.#restoreAfterFailedOpen(previous, primary);
@@ -351,16 +381,22 @@ export class BinarySession extends BinarySessionRecords {
             : analysisErrorWithCleanupFailure(primary, restored.error, "open_binary");
     }
     /** Describe the active binary session. */
-    status() {
+    status(options = {}) {
+        const run = this.#active ?? this.#pendingCleanup?.run;
+        const client = run?.client;
         return binarySessionStatus({
+            ...options,
             target: this.#active?.target,
             route: this.#currentRoute(),
             router: this.#providerRouter,
             runtimeUnavailability: this.#runtimeUnavailability,
-            runId: this.#active?.runId,
-            runtimeLineageSnapshots: this.#active?.client.runtimeLineageSnapshots?.() ?? [],
-            requestActivitySnapshots: this.#active?.client.requestActivitySnapshots?.() ?? [],
-            providerOperationHealth: this.#active?.client.operationHealthSnapshot?.() ?? null,
+            runId: run?.runId,
+            runtimeLineageSnapshots: client?.runtimeLineageSnapshots?.() ?? [],
+            requestActivitySnapshots: client?.requestActivitySnapshots?.() ?? [],
+            providerOperationHealth: client?.operationHealthSnapshot?.() ?? null,
+            cleanupPending: this.#pendingCleanup !== undefined ||
+                this.hasPendingFileResources ||
+                this.#providerRouter.hasPendingOwnedResources(),
         });
     }
     /** Return the immutable artifact identity captured before its provider started. */
@@ -603,6 +639,8 @@ export class BinarySession extends BinarySessionRecords {
      * to the `health` admission probe.
      */
     async #retainedClientLive(client, options) {
+        if (client.reuseReadiness?.() === "blocked")
+            return false;
         const snapshot = client.operationHealthSnapshot?.();
         if (snapshot !== undefined)
             return snapshot.state === "idle" || snapshot.state === "busy";
@@ -617,21 +655,22 @@ export class BinarySession extends BinarySessionRecords {
         if (previous === undefined)
             return ok(null);
         const runId = randomUUID();
-        const client = previous.route.createClient(previous.target, { runId });
+        const client = previous.route.createClient(previous.target, {
+            runId,
+        });
+        const run = { client, route: previous.route, runId };
         const started = await client.execute("health", {});
         if (started.ok) {
             this.#active = {
                 target: previous.target,
-                client,
                 profile: previous.profile,
-                route: previous.route,
-                runId,
+                ...run,
                 nativeSourceAdmitted: false,
             };
             this.#clearRuntimeAvailability();
             return ok(null);
         }
-        const closed = await this.#retireClient(client, previous.route.identity.id);
+        const closed = await this.#retireClient(run);
         return closed.ok
             ? ok(null)
             : err(analysisErrorWithCleanupFailure(started.error, closed.error, "open_binary"));

package/dist/application/binary/BinarySessionRecords.js

@@ -11,6 +11,9 @@ const SNAPSHOT_MUTATION_RECOVERY = "Export session observations through export_e
 export class BinarySessionRecords {
     #records;
     #writeResources = new ArtifactResourceScope();
+    get hasPendingFileResources() {
+        return this.#writeResources.hasPending;
+    }
     #snapshot = new AnalysisSnapshotCache();
     #snapshotInvalidated = false;
     #snapshotListeners = new Set();

package/dist/application/binary/BinarySessionStatus.js

@@ -2,7 +2,7 @@ import { binaryTargetSummary } from "./BinaryTargetSummary.js";
 import { PROVIDER_EFFECT_NAMES, } from "../../contracts/toolOutputSchemaPrimitives.js";
 import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 /** Project internal provider routing state into the caller-visible session status. */
-export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, }) => {
+export const binarySessionStatus = async ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, cleanupPending = false, signal, }) => {
     const routeCapabilities = [...route.capabilities.values()]
         .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation))
@@ -24,9 +24,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
             selection_source: route.binding.selectionSource,
             analysis_profile: structuredClone(route.binding.profile),
         };
-    const analysisProviderCandidates = router
-        .candidateStatuses(route)
-        .map((candidate) => ({
+    const analysisProviderCandidates = (await router.candidateStatuses(route, signal)).map((candidate) => ({
         provider: providerSummary(candidate.provider),
         availability: structuredClone(candidate.availability),
         target_support: structuredClone(candidate.targetSupport),
@@ -37,6 +35,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
             .sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation))),
     }));
     const common = {
+        cleanup_pending: cleanupPending,
         capabilities,
         analysis_provider_binding: analysisProviderBinding,
         analysis_provider_candidates: analysisProviderCandidates,

package/dist/application/binary/CompositeProvider.js

@@ -1,8 +1,9 @@
 import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { err, ok } from "../../domain/result.js";
-import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
+import { closeAnalysisClient } from "../../providers/AnalysisClientCleanup.js";
 import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 /** Synthetic identity for a deterministic provider set. */
 const compositeProviderIdentity = (identities) => ({
@@ -13,32 +14,48 @@ const compositeProviderIdentity = (identities) => ({
     name: "REA composite analysis provider",
     version: null,
 });
-const closeCompositeClients = (identity, clients) => async (options) => {
-    const outcomes = await Promise.all([...clients.entries()].map(([provider, client]) => closeAnalysisClient(client, provider.identity().id, options).then((result) => ({ providerId: provider.identity().id, result }))));
-    const failures = outcomes.flatMap(({ providerId, result }) => result.ok ? [] : [{ providerId, error: result.error }]);
-    if (failures.length === 0)
-        return ok(null);
-    if (failures.length === 1) {
-        const failure = failures[0];
-        if (failure !== undefined)
-            return err(failure.error);
-    }
-    const resources = [
-        ...new Set(failures.flatMap(({ error }) => error.cleanupResources)),
-    ];
-    return err(new ProviderCleanupError(identity.id, resources, {
-        reason: "Multiple composed provider clients could not be confirmed closed.",
-        failures: failures.map(({ providerId, error }) => ({
-            provider_id: providerId,
-            message: error.message,
-            resources: [...error.cleanupResources],
-            ...(error.diagnostics === undefined
-                ? {}
-                : { diagnostics: error.diagnostics }),
-        })),
-    }, {
-        cause: new AggregateError(failures.map(({ error }) => error), "Composed provider cleanup failed."),
-    }));
+const closeCompositeClients = (identity, clients) => {
+    const completed = new Set();
+    return async (options) => {
+        const outcomes = await Promise.all([...clients.entries()].map(async ([provider, client]) => {
+            const providerId = provider.identity().id;
+            if (completed.has(client))
+                return { providerId, result: ok(null) };
+            const result = await closeAnalysisClient(client, providerId, options);
+            if (result.ok)
+                completed.add(client);
+            return { providerId, result };
+        }));
+        const failures = outcomes.flatMap(({ providerId, result }) => result.ok ? [] : [{ providerId, error: result.error }]);
+        if (failures.length === 0)
+            return ok(null);
+        if (failures.length === 1) {
+            const failure = failures[0];
+            if (failure !== undefined)
+                return err(failure.error);
+        }
+        const resources = [
+            ...new Set(failures.flatMap(({ error }) => error.cleanupResources)),
+        ];
+        return err(new ProviderCleanupError(identity.id, resources, {
+            reason: "Multiple composed provider clients could not be confirmed closed.",
+            failures: failures.map(({ providerId, error }) => ({
+                provider_id: providerId,
+                message: error.message,
+                resources: [...error.cleanupResources],
+                ...(error.diagnostics === undefined
+                    ? {}
+                    : { diagnostics: error.diagnostics }),
+            })),
+        }, {
+            remediationAction: [
+                ...new Set(failures.map(({ error }) => projectAnalysisError(error).remediation.action)),
+            ].join("\n"),
+            cause: new AggregateError(failures.map(({ error }) => error), "Composed provider cleanup failed."),
+        }).bindCleanupDependencies(failures
+            .map(({ error }) => error)
+            .filter((error) => error.cleanupIncomplete)));
+    };
 };
 const executeCompositeHealth = async (identity, clients, options) => {
     for (const [provider, client] of clients) {
@@ -105,15 +122,24 @@ export class CompositeProvider {
             clients.set(provider, created);
             return created;
         };
-        const close = closeCompositeClients(this.#identity, clients);
+        let closed = false;
+        const closeClients = closeCompositeClients(this.#identity, clients);
+        const close = (options) => {
+            closed = true;
+            return closeClients(options);
+        };
         return {
             executeIfReady: (operation, parameters, options) => {
                 const provider = this.#providerByOperation.get(operation);
-                const client = provider === undefined ? undefined : clients.get(provider);
+                const client = provider === undefined || closed ? undefined : clients.get(provider);
                 return (client?.executeIfReady?.(operation, parameters, options) ??
                     Promise.resolve(undefined));
             },
             execute: async (operation, parameters, options) => {
+                if (closed)
+                    return err(new ProviderAdapterError(this.#identity.id, operation, {
+                        diagnostics: { reason: "client_closed" },
+                    }));
                 if (operation === "health")
                     return executeCompositeHealth(this.#identity, clients, options);
                 const provider = this.#providerByOperation.get(operation);
@@ -127,11 +153,30 @@ export class CompositeProvider {
             requestActivitySnapshots: () => [...clients.values()]
                 .flatMap((client) => client.requestActivitySnapshots?.() ?? [])
                 .sort((left, right) => compareUnicodeCodePoints(left.provider.id, right.provider.id)),
+            reuseReadiness: () => {
+                if (closed)
+                    return "blocked";
+                const states = [...clients.values()].map((client) => client.reuseReadiness?.() ?? "unknown");
+                if (states.some((state) => state === "blocked"))
+                    return "blocked";
+                return states.some((state) => state === "unknown")
+                    ? "unknown"
+                    : "ready";
+            },
             operationHealthSnapshot: () => {
                 const snapshots = [...clients.values()].map((client) => client.operationHealthSnapshot?.());
+                const failed = snapshots.find((snapshot) => snapshot !== undefined &&
+                    (snapshot.state === "exited" ||
+                        snapshot.state === "unreachable" ||
+                        snapshot.state === "not_started"));
+                if (failed !== undefined)
+                    return failed;
+                const nonIdle = snapshots.find((snapshot) => snapshot !== undefined && snapshot.state !== "idle");
+                if (nonIdle !== undefined)
+                    return nonIdle;
                 if (snapshots.some((snapshot) => snapshot === undefined))
                     return undefined;
-                return (snapshots.find((snapshot) => snapshot !== undefined && snapshot.state !== "idle") ?? snapshots[0]);
+                return snapshots[0];
             },
             close,
         };

package/dist/application/binary/LazyAnalysisProvider.js

@@ -1,9 +1,5 @@
 import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
-import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
-import { err, ok } from "../../domain/result.js";
-import { ABORTED, waitForAbortable } from "../../process/AbortablePromise.js";
-const isAborted = (signal) => signal?.aborted === true;
+import { DeferredAnalysisClient } from "../../providers/DeferredAnalysisClient.js";
 /**
  * Preserve synchronous provider discovery while loading implementation modules
  * only when a target-bound client first executes.
@@ -28,8 +24,12 @@ export class LazyAnalysisProvider {
     }
     /** Create a client whose implementation is loaded on first execution. */
     createClient(target, profile, context) {
-        return new LazyAnalysisClient(async () => {
+        return new DeferredAnalysisClient(async (signal) => {
             const provider = await this.#load();
+            if (signal.aborted)
+                throw new AnalysisCancelledError("create_analysis_client", {
+                    cause: signal.reason,
+                });
             return provider.createClient(target, profile, context);
         }, this.#providerIdentity.id);
     }
@@ -41,65 +41,3 @@ export class LazyAnalysisProvider {
         return this.#provider;
     }
 }
-class LazyAnalysisClient {
-    #loadClient;
-    #providerId;
-    #client;
-    #loading;
-    #closed = false;
-    executeIfReady = (operation, parameters, options) => this.#client?.executeIfReady?.(operation, parameters, options) ??
-        Promise.resolve(undefined);
-    constructor(loadClient, providerId) {
-        this.#loadClient = loadClient;
-        this.#providerId = providerId;
-    }
-    execute = async (operation, parameters, options) => {
-        try {
-            if (isAborted(options?.signal))
-                return err(new AnalysisCancelledError(operation));
-            const loaded = await waitForAbortable(this.#load(operation), options?.signal);
-            if (loaded === ABORTED)
-                return err(new AnalysisCancelledError(operation));
-            return await loaded.execute(operation, parameters, options);
-        }
-        catch (cause) {
-            if (cause instanceof AnalysisError)
-                return err(cause);
-            return err(new ProviderAdapterError(this.#providerId, operation, {
-                cause,
-            }));
-        }
-    };
-    runtimeLineageSnapshots() {
-        return this.#client?.runtimeLineageSnapshots?.() ?? [];
-    }
-    requestActivitySnapshots() {
-        return this.#client?.requestActivitySnapshots?.() ?? [];
-    }
-    operationHealthSnapshot() {
-        return this.#client?.operationHealthSnapshot?.();
-    }
-    close = async (options) => {
-        this.#closed = true;
-        if (this.#loading === undefined)
-            return ok(null);
-        const client = await this.#loading;
-        return client.close(options);
-    };
-    async #load(operation) {
-        if (this.#closed)
-            throw new ProviderAdapterError(this.#providerId, operation, {
-                diagnostics: { reason: "client_closed" },
-            });
-        this.#loading ??= this.#loadClient()
-            .then((client) => {
-            this.#client = client;
-            return client;
-        })
-            .catch((cause) => {
-            this.#loading = undefined;
-            throw cause;
-        });
-        return this.#loading;
-    }
-}

package/dist/application/binary/SessionProviderRouter.js

@@ -31,6 +31,14 @@ export class SessionProviderRouter {
     initialRoute() {
         return this.route;
     }
+    /** Close provider owners not represented by the currently bound client. */
+    closeOwnedResources() {
+        return this.registry.closeOwnedResources();
+    }
+    /** Report retained candidate cleanup without performing cleanup work. */
+    hasPendingOwnedResources() {
+        return this.registry.hasPendingOwnedResources();
+    }
     /** Resolve target routes before any provider client is created. */
     async resolve(target, providerId, signal) {
         const resolutionOptions = signal === undefined ? undefined : { signal };
@@ -40,8 +48,9 @@ export class SessionProviderRouter {
             : selected;
     }
     /** Candidate status authoritative for the active or target-free route. */
-    candidateStatuses(route) {
-        return route.selection?.candidates ?? this.registry.candidates();
+    async candidateStatuses(route, signal) {
+        return (route.selection?.candidates ??
+            this.registry.candidates(undefined, signal === undefined ? {} : { signal }));
     }
     /** Produce exact candidate rejections for an intentionally unbound route. */
     unboundOperationError(operation, route) {

package/dist/application/binaryDiagnostics/BinaryLayoutService.js

@@ -4,6 +4,7 @@ import { createEvidence } from "../../domain/evidence.js";
 import { inspectBinaryLayoutInputSchema, binaryLayoutSchema, } from "../../domain/native/binaryLayout.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 const OPERATION = "inspect_binary_layout";
 /** Shared CLI/MCP validation and Evidence composition for offline layout inspection. */
 export class BinaryLayoutService {
@@ -45,13 +46,11 @@ export class BinaryLayoutService {
         const outputOptions = diagnostics.success
             ? { capturedOutput: diagnostics.data }
             : undefined;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION, outputOptions));
         const report = binaryLayoutSchema.safeParse(inspected.value);
         if (!report.success || report.data.artifact.path !== input.data.path)
             return err(new AnalysisOutputError(OPERATION, "Binary layout provider returned malformed evidence or changed the selected artifact identity.", outputOptions));
         const value = report.data;
-        return ok(createEvidence({
+        return completeProviderEvidence(createEvidence({
             path: value.artifact.path,
             format: "elf",
             architecture: "x86_64",
@@ -65,6 +64,6 @@ export class BinaryLayoutService {
             confidence: "observed",
             limitations: value.limitations,
             locations: [{ kind: "artifact-path", path: value.artifact.path }],
-        }));
+        }), options?.signal, outputOptions?.capturedOutput);
     }
 }

package/dist/application/binaryDiagnostics/PeResourcesService.js

@@ -3,7 +3,9 @@ import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from
 import { createEvidence } from "../../domain/evidence.js";
 import { inspectPeResourcesInputSchema, peResourcesSchema, } from "../../domain/native/peResources.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { decodePeMachine, peOptionalHeaderMagic, } from "../../domain/peMachine.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 /** Shared caller validation, output parsing and Evidence provenance for CLI/MCP. */
 export class PeResourcesService {
     provider;
@@ -16,7 +18,7 @@ export class PeResourcesService {
     async inspect(rawInput, options) {
         const operation = "inspect_pe_resources";
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
+            return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
         const input = inspectPeResourcesInputSchema.safeParse(rawInput);
         if (!input.success)
             return err(analysisInputErrorFromIssues(operation, input.error.issues, rawInput, {
@@ -33,18 +35,18 @@ export class PeResourcesService {
         const result = await this.provider.inspect(input.data, options);
         if (!result.ok)
             return result;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
         const report = peResourcesSchema.safeParse(result.value);
         if (!report.success ||
             report.data.artifact.path !== input.data.path ||
             !validReport(report.data, input.data.max_entries, input.data.max_file_bytes))
             return err(new AnalysisOutputError(operation, "PE resource provider returned malformed output or changed artifact identity."));
         const value = report.data;
-        return ok(createEvidence({
+        const architecture = subjectArchitecture(value);
+        return completeProviderEvidence(createEvidence({
             path: value.artifact.path,
             format: "pe",
             sha256: value.artifact.sha256,
+            ...(architecture === undefined ? {} : { architecture }),
         }, this.provider.identity, {
             operation,
             parameters: input.data,
@@ -52,9 +54,24 @@ export class PeResourcesService {
             confidence: "observed",
             limitations: value.limitations,
             locations: [{ kind: "artifact-path", path: value.artifact.path }],
-        }));
+        }), options?.signal);
     }
 }
+/**
+ * Name the subject architecture from the reported COFF machine. The resource
+ * reader does not inspect the CLI header, so a ReadyToRun OS-override machine
+ * needs separate proof. An optional-header magic that contradicts the machine
+ * is observed conflicting evidence. Both stay unknown.
+ */
+const subjectArchitecture = (report) => {
+    const machine = decodePeMachine(report.machine);
+    if (machine === undefined || machine.nativeOsOverride)
+        return undefined;
+    const magic = report.format === "pe32-plus" ? 0x20b : 0x10b;
+    return magic === peOptionalHeaderMagic(machine.architecture)
+        ? machine.architecture
+        : undefined;
+};
 /** Check cross-field invariants before provider output becomes public Evidence. */
 const validReport = (report, maxEntries, maxBytes) => {
     const inside = ({ offset, bytes }) => offset <= report.artifact.bytes - bytes;