rea-agents 6.5.0 → 6.7.0

package/dist/application/Uninstall.js

@@ -1,16 +1,18 @@
+import { isClientConfigurationCleanupFailure, retryClientConfigurationCleanup, } from "./ClientConfigurationCleanup.js";
 import { ClientConfigurationShapeError, parseClientConfiguration, serializeClientConfiguration, clientServerPath, legacyClientServerPath, withClientServers, } from "./ClientConfigurationDocument.js";
 import { copyFile, lstat, realpath, rm, rmdir } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { join } from "node:path";
-import writeFileAtomic from "write-file-atomic";
+import { ClientConfigurationPublication } from "./ClientConfigurationPublication.js";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { isManagedSkillManifest, MANAGED_SKILL_FILES, readSkillFile, skillDestinations, } from "./SetupSkill.js";
-import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
+import { classifyClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { CURRENT_ENTRYPOINT_PATH } from "../process/CurrentEntrypointPath.js";
 import { dshDocument } from "./DshCordisPatch.js";
 import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
+import { preserveCurrentRecoveryBackup, } from "./SetupRecoveryBackup.js";
 import { InvalidUtf8FileError, RegularFileCleanupFailure, readRegularFileText, } from "./RegularFileRead.js";
 import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { appDataRedirection, manualRegistrationRemediation, registrationWriteBlocker, supportedClients, } from "./SupportedClients.js";
@@ -20,7 +22,7 @@ const systemFileSystem = (resources) => ({
     readText: (path) => readRegularFileText(path, { resources }),
     readRegularText: (path) => readSkillFile(path, resources),
     copy: (source, destination) => copyFile(source, destination, fsConstants.COPYFILE_EXCL),
-    writeText: (path, contents) => writeFileAtomic(path, contents, { encoding: "utf8" }),
+    publishConfiguration: (path, contents, original) => ClientConfigurationPublication.write(path, contents, original),
     stat: (path) => lstat(path),
     realpath: (path) => realpath(path),
     remove: (path, recursive = true) => rm(path, { recursive }),
@@ -116,6 +118,9 @@ const removeAll = async (clients, purgeData, host) => {
 export const systemUninstallHost = (selectedHome = undefined, selectedFileSystem = undefined, environment = process.env, platform = process.platform) => {
     const home = selectedHome ?? homeDirectoryFromEnvironment(environment, platform);
     const resources = new ArtifactResourceScope();
+    // Whole-operation admission must not share a gate with its nested file reads:
+    // a peer's pending cleanup otherwise waits for the operation requesting it.
+    const configurationOperations = new ArtifactResourceScope();
     const fileSystem = selectedFileSystem ?? systemFileSystem(resources);
     // Set with the client list: the package view that redirects this
     // process's AppData writes, if any.
@@ -143,8 +148,8 @@ export const systemUninstallHost = (selectedHome = undefined, selectedFileSystem
                     ]),
             ]));
         },
-        inspectClient: async (client) => {
-            const read = await readClientConfiguration(client, fileSystem);
+        inspectClient: (client) => configurationOperations.run(async () => {
+            const read = await readClientConfiguration(client, fileSystem, resources);
             if (read.kind === "item")
                 return read.item.status === "failed" ? read.item : undefined;
             const removal = clientRegistrationRemoval(read.parsed, client);
@@ -156,8 +161,8 @@ export const systemUninstallHost = (selectedHome = undefined, selectedFileSystem
             return blocker === undefined
                 ? undefined
                 : item(client.name, "failed", blocker);
-        },
-        removeClient: (client) => removeClient(client, fileSystem, () => clientWriteBlocker(client)),
+        }),
+        removeClient: (client) => configurationOperations.run(() => removeClient(client, fileSystem, resources, () => clientWriteBlocker(client))),
         inspectSkill: async () => {
             for (const destination of skillDestinations(home, undefined, environment, platform)) {
                 const inspected = await inspectManagedSkill(destination.path, destination.client, fileSystem);
@@ -175,6 +180,7 @@ export const systemUninstallHost = (selectedHome = undefined, selectedFileSystem
         purgeData: () => purgeManagedData(join(home, ".rea"), fileSystem),
         close: async () => {
             try {
+                await configurationOperations.close();
                 await resources.close();
                 return undefined;
             }
@@ -210,7 +216,7 @@ const registrationPresent = (parsed) => {
         // still belongs to that id, and so does a direct patch that projects no row.
         (parsed.dialect === "dsh" && dshDocument(parsed.document).carriesEntry));
 };
-const readClientConfiguration = async (client, fileSystem) => {
+const readClientConfiguration = async (client, fileSystem, resources) => {
     if (client.configPathError !== undefined)
         return itemRead(item(client.name, "failed", client.configPathError));
     if (client.format === "unsupported")
@@ -225,8 +231,14 @@ const readClientConfiguration = async (client, fileSystem) => {
         original = await fileSystem.readText(transactionPath);
     }
     catch (cause) {
-        const readFailure = cause instanceof RegularFileCleanupFailure ? cause.cause : cause;
-        return itemRead(isMissing(cause)
+        if (isClientConfigurationCleanupFailure(cause)) {
+            const cleanup = await retryClientConfigurationCleanup(cause, resources);
+            return itemRead(item(client.name, "failed", cleanup.primary instanceof InvalidUtf8FileError
+                ? "Configuration is not valid UTF-8 and was not changed; its resources could not be released. Repair it, then rerun uninstall."
+                : "Configuration could not be read or its resources could not be released. Check file permissions, then rerun uninstall."));
+        }
+        const readFailure = cause;
+        return itemRead(isMissing(readFailure)
             ? item(client.name, "skipped", "Configuration does not exist.")
             : item(client.name, "failed", readFailure instanceof InvalidUtf8FileError
                 ? "Configuration is not valid UTF-8 and was not changed. Repair it, then rerun uninstall."
@@ -267,8 +279,25 @@ const clientRegistrationRemoval = (parsed, client) => {
             : undefined,
     };
 };
-const removeClient = async (client, fileSystem, writeBlocker) => {
-    const read = await readClientConfiguration(client, fileSystem);
+/** Preserve the bytes uninstall is about to edit and return the backup holding them. */
+const backupClientConfiguration = async (client, transactionPath, original, options) => {
+    const failed = (detail) => item(client.name, "failed", `Configuration could not be backed up, so no change was made. ${detail}`);
+    try {
+        const preserved = await preserveCurrentRecoveryBackup(`${client.configPath}.rea.backup`, transactionPath, original, options);
+        if (preserved.ok)
+            return preserved.value;
+        if (preserved.error.kind === "occupied")
+            return failed(`${preserved.error.detail}. Move that file aside, then rerun uninstall.`);
+    }
+    catch (cause) {
+        // The resource scope retains a backup handle whose close failed.
+        if (!(cause instanceof RegularFileCleanupFailure))
+            throw cause;
+    }
+    return failed("Check file permissions, then rerun uninstall.");
+};
+const removeClient = async (client, fileSystem, resources, writeBlocker) => {
+    const read = await readClientConfiguration(client, fileSystem, resources);
     if (read.kind === "item")
         return read.item;
     const { transactionPath, original, parsed } = read;
@@ -293,35 +322,60 @@ const removeClient = async (client, fileSystem, writeBlocker) => {
         ...(removeNative ? [clientServerPath(parsed, name)] : []),
         ...(legacyPath === undefined ? [] : [legacyPath]),
     ];
-    const backupPath = `${client.configPath}.rea.backup`;
+    let serialized;
+    try {
+        serialized = serializeClientConfiguration(document, client.format, original, editedPaths);
+    }
+    catch {
+        return item(client.name, "failed", "Configuration could not be updated, so no change was made. Repair the configuration, then rerun uninstall.");
+    }
+    if (!serialized.ok)
+        return item(client.name, "failed", `Configuration repeats the member at ${JSON.stringify(serialized.error.path)}; removing the registration the client reads would activate an earlier duplicate, so no change was made. Remove the duplicate members manually, then rerun uninstall.`);
+    const backupPath = await backupClientConfiguration(client, transactionPath, original, {
+        copy: (source, destination) => fileSystem.copy(source, destination),
+        resources,
+    });
+    if (typeof backupPath !== "string")
+        return backupPath;
+    const manualRecovery = () => item(client.name, "failed", `Configuration could not be updated or restored. Restore the backup at ${backupPath} manually, then rerun uninstall.`);
+    let publication;
     try {
-        await fileSystem.copy(transactionPath, backupPath);
+        publication = await fileSystem.publishConfiguration(transactionPath, serialized.value, original);
     }
     catch (cause) {
-        if (!(cause instanceof Error && "code" in cause && cause.code === "EEXIST"))
-            return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
+        if (isClientConfigurationCleanupFailure(cause))
+            await retryClientConfigurationCleanup(cause, resources);
+        return manualRecovery();
     }
     try {
-        await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format, original, editedPaths));
-        const readback = parseClientConfiguration(await fileSystem.readText(transactionPath), client.format);
-        if ((removeNative && Object.hasOwn(readback.servers, name)) ||
-            (readback.dialect === "dsh" &&
-                dshDocument(readback.document).carriesEntry) ||
-            (removeLegacy && Object.hasOwn(readback.legacyServers, name)))
-            throw new Error("registration readback mismatch");
-        return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
+        return await publication.verify(async () => {
+            try {
+                const readback = parseClientConfiguration(await fileSystem.readText(publication.path), client.format);
+                await publication.assertCurrent();
+                if ((removeNative && Object.hasOwn(readback.servers, name)) ||
+                    (readback.dialect === "dsh" &&
+                        dshDocument(readback.document).carriesEntry) ||
+                    (removeLegacy && Object.hasOwn(readback.legacyServers, name)))
+                    throw new Error("registration readback mismatch");
+                return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
+            }
+            catch (cause) {
+                if (isClientConfigurationCleanupFailure(cause))
+                    await retryClientConfigurationCleanup(cause, resources);
+                try {
+                    await publication.restore(original);
+                }
+                catch {
+                    return manualRecovery();
+                }
+                return item(client.name, "failed", `Configuration could not be updated. The original was restored and its backup at ${backupPath} was retained. Repair the configuration or restore that backup, then rerun uninstall.`);
+            }
+        });
     }
     catch (cause) {
-        // Update failure attempts a restore before reporting; cause is preserved below.
-        void cause;
-        try {
-            await fileSystem.writeText(transactionPath, original);
-        }
-        catch (restoreCause) {
-            void restoreCause;
-            return item(client.name, "failed", "Configuration could not be updated or restored. Restore its `.rea.backup` manually, then rerun uninstall.");
-        }
-        return item(client.name, "failed", "Configuration could not be updated. The original was restored and its `.rea.backup` was retained. Repair the configuration or restore the backup, then rerun uninstall.");
+        if (isClientConfigurationCleanupFailure(cause))
+            await retryClientConfigurationCleanup(cause, resources);
+        return item(client.name, "failed", `Configuration verification or resource cleanup failed. The backup at ${backupPath} was retained. Check the configuration and rerun uninstall.`);
     }
 };
 const resolveUninstallConfigPath = async (client, fileSystem) => {
@@ -341,13 +395,14 @@ const isOwnedRegistration = (value, client) => {
         if (!parsed.success)
             return false;
         const command = parsed.data.command;
-        return isOwnedClientRegistrationCommand(command, CURRENT_ENTRYPOINT_PATH);
+        return (classifyClientRegistrationCommand(command, CURRENT_ENTRYPOINT_PATH) ===
+            "owned");
     }
     const parsed = registrationSchema.safeParse(value);
     if (!parsed.success)
         return false;
     const { command, args } = parsed.data;
-    return isOwnedClientRegistrationCommand([command, ...args], CURRENT_ENTRYPOINT_PATH);
+    return (classifyClientRegistrationCommand([command, ...args], CURRENT_ENTRYPOINT_PATH) === "owned");
 };
 const purgeManagedData = async (root, fileSystem) => {
     const names = ["cache", "state"];

package/dist/application/UpdateCommandProgress.js

@@ -0,0 +1,66 @@
+import { Writable } from "node:stream";
+import { finished } from "node:stream/promises";
+/** Borrow a progress destination while owning backpressure and write acknowledgements. */
+export class UpdateCommandProgress {
+    destination;
+    #streams = [];
+    #sink;
+    #finished;
+    #closing;
+    #failed = false;
+    #pendingWrites = 0;
+    #closed = false;
+    #onDestinationError = (cause) => {
+        this.#sink.destroy(cause);
+    };
+    constructor(destination) {
+        this.destination = destination;
+        this.#sink = new Writable({
+            write: (chunk, encoding, callback) => {
+                this.#pendingWrites++;
+                destination.write(chunk, encoding, (cause) => {
+                    this.#pendingWrites--;
+                    callback(cause);
+                    // A destination can emit its write error after invoking the callback.
+                    setImmediate(() => this.#releaseDestination());
+                });
+            },
+        });
+        this.#finished = finished(this.#sink, { cleanup: true }).then(() => undefined, (cause) => {
+            this.#failed = true;
+            for (const stream of this.#streams) {
+                stream.unpipe(this.#sink);
+                stream.resume();
+            }
+            return cause instanceof Error ? cause : new Error(String(cause));
+        });
+        destination.on("error", this.#onDestinationError);
+    }
+    pipe(stream) {
+        this.#streams.push(stream);
+        if (this.#failed)
+            stream.resume();
+        else
+            stream.pipe(this.#sink, { end: false });
+    }
+    close() {
+        this.#closing ??= this.#close();
+        return this.#closing;
+    }
+    async #close() {
+        for (const stream of this.#streams)
+            stream.unpipe(this.#sink);
+        this.#sink.end();
+        try {
+            return await this.#finished;
+        }
+        finally {
+            this.#closed = true;
+            setImmediate(() => this.#releaseDestination());
+        }
+    }
+    #releaseDestination() {
+        if (this.#closed && this.#pendingWrites === 0)
+            this.destination.off("error", this.#onDestinationError);
+    }
+}

package/dist/application/UpdateMaintenance.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
+import { RegularFileCleanupFailure } from "./RegularFileRead.js";
+import { classifyClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { readClientRegistrationInspections } from "./ClientRegistrationStatus.js";
 import { existingSkillDestinations } from "./SetupSkill.js";
 const setupPlanSchema = z.object({
@@ -26,7 +27,8 @@ export const existingMaintenanceScope = async (home, entryPoint, environment, re
     for (const { status: registration, activation } of registrations) {
         if (activation !== "enabled" ||
             (registration.state !== "aligned" && registration.state !== "stale") ||
-            !isOwnedClientRegistrationCommand(registration.command, entryPoint))
+            classifyClientRegistrationCommand(registration.command, entryPoint) !==
+                "owned")
             continue;
         clients.push(registration.client);
     }
@@ -84,6 +86,9 @@ export const planIntegrationMaintenance = async (home, entryPoint, environment,
         };
     }
     catch (cause) {
+        // Without a supplied scope, the typed failure is the caller's cleanup capability.
+        if (resources === undefined && cause instanceof RegularFileCleanupFailure)
+            throw cause;
         return {
             status: "unavailable",
             remediation: cause instanceof Error ? cause.message : String(cause),

package/dist/application/UpdateRuntime.js

@@ -3,6 +3,8 @@ import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import spawn from "cross-spawn";
+import { ProviderProcessSupervisor } from "../process/ProviderProcess.js";
+import { UpdateCommandProgress } from "./UpdateCommandProgress.js";
 import { lt, valid } from "semver";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
@@ -11,14 +13,14 @@ import { safeParseJson } from "../domain/safeJson.js";
 import { updateInstallCommand, } from "./Update.js";
 import { planIntegrationMaintenance } from "./UpdateMaintenance.js";
 import { withoutPackageRunnerIdentity } from "./ClientRegistrationIdentity.js";
-/** Run an updater subprocess with complete diagnostics and isolated machine output. */
-export const runUpdateCommand = (command, selectedEnvironment, output = "structured", workingDirectory = undefined) => new Promise((resolveResult) => {
+/** Aggregate raw-byte retention policy for package-manager replies and diagnostics. */
+export const UPDATE_COMMAND_OUTPUT_BYTES = 4 * 1024 * 1024;
+/** Complete metadata queries share launch and collection with diagnostic-only installs. */
+export const runUpdateCommand = (command, selectedEnvironment, output = "structured", workingDirectory = undefined) => runUpdateProcess(command, selectedEnvironment, output, workingDirectory, "complete");
+const runUpdateProcess = async (command, selectedEnvironment, output, workingDirectory, retention) => {
     const [executable, ...args] = command;
-    if (executable === undefined) {
-        resolveResult(err("No executable supplied."));
-        return;
-    }
-    // A fresh installed entry point must not inherit a package runner's invocation identity.
+    if (executable === undefined)
+        return err("No executable supplied.");
     const environment = withoutPackageRunnerIdentity(selectedEnvironment);
     const child = spawn(executable, args, {
         stdio: ["ignore", "pipe", "pipe"],
@@ -26,29 +28,57 @@ export const runUpdateCommand = (command, selectedEnvironment, output = "structu
         windowsHide: true,
         ...(workingDirectory === undefined ? {} : { cwd: workingDirectory }),
     });
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-        stdout += chunk;
-        if (output === "human")
-            process.stderr.write(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-        stderr += chunk;
-        if (output === "human")
-            process.stderr.write(chunk);
+    let processFailure;
+    const supervisor = new ProviderProcessSupervisor({ process: child, ownsProcessLifetime: true }, {
+        maxDiagnosticBytes: UPDATE_COMMAND_OUTPUT_BYTES,
+        onDiagnostic: (event) => {
+            if (event.type === "error")
+                processFailure ??= event.message;
+        },
     });
-    child.once("error", (cause) => resolveResult(err(cause.message)));
-    child.once("close", (code, signal) => resolveResult(code === 0
-        ? ok(stdout.trim())
-        : err(stderr.trim() ||
-            stdout.trim() ||
-            (signal === null
-                ? `Process exited with code ${String(code)}.`
-                : `Process terminated by ${signal}.`))));
-});
+    const progress = output === "human" ? new UpdateCommandProgress(process.stderr) : undefined;
+    if (progress !== undefined) {
+        for (const stream of [child.stdout, child.stderr])
+            if (stream !== null)
+                progress.pipe(stream);
+    }
+    try {
+        // Drain even an oversized reply. Verbosity must not interrupt a package install.
+        // Keep the existing launch/signal policy; this collector owns no process-tree authority.
+        await supervisor.waitForOutputClose();
+        const progressFailure = await progress?.close();
+        const snapshot = supervisor.snapshot();
+        if (processFailure !== undefined)
+            return err(processFailure);
+        if (snapshot.outputIncomplete === true)
+            return err("Update command output did not close completely.");
+        if (retention === "complete" && snapshot.diagnosticTruncated === true)
+            return err(`Update command output exceeded the ${UPDATE_COMMAND_OUTPUT_BYTES}-byte complete-output retention budget; reply was not accepted.`);
+        if (snapshot.exitCode !== 0 || snapshot.signal !== null) {
+            const detail = snapshot.stderr.text.trim() ||
+                snapshot.stdout.text.trim() ||
+                (typeof snapshot.signal === "string"
+                    ? `Process terminated by ${snapshot.signal}.`
+                    : typeof snapshot.exitCode === "number"
+                        ? `Process exited with code ${snapshot.exitCode}.`
+                        : "Update command failed without a recorded exit status.");
+            return err(snapshot.diagnosticTruncated
+                ? `${detail}\n[Update diagnostics truncated at ${UPDATE_COMMAND_OUTPUT_BYTES} bytes; later output omitted.]`
+                : detail);
+        }
+        if (retention === "complete" &&
+            (snapshot.stdout.invalidUtf8 || snapshot.stderr.invalidUtf8))
+            return err("Update command returned invalid UTF-8; complete output is unavailable.");
+        if (progressFailure !== undefined)
+            return err(`Update progress output failed: ${progressFailure.message}`);
+        return ok(retention === "diagnostics" ? "" : snapshot.stdout.text.trim());
+    }
+    finally {
+        // Reached only after physical close; no child or inherited pipe remains pending.
+        supervisor.dispose();
+        await progress?.close();
+    }
+};
 const requireCommandOutput = async (command, environment) => {
     const result = await runUpdateCommand(command, environment);
     if (!result.ok)
@@ -242,7 +272,7 @@ export const systemUpdateHost = (packageRoot = fileURLToPath(new URL("../..", im
         },
         installVersion: async (installation, version, output) => {
             const context = packageManagerContext(installation, environment);
-            const result = await runUpdateCommand(updateInstallCommand(installation, version), context.environment, output, context.workingDirectory);
+            const result = await runUpdateProcess(updateInstallCommand(installation, version), context.environment, output, context.workingDirectory, "diagnostics");
             return result.ok ? ok(undefined) : result;
         },
         installedVersion: (installation) => runUpdateCommand([

package/dist/application/WebModuleTraceService.js

@@ -1,4 +1,5 @@
 import { closeOwnedWebResources } from "./closeOwnedWebResources.js";
+import { isDeepStrictEqual } from "node:util";
 import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
@@ -7,9 +8,10 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { err, ok } from "../domain/result.js";
 import { collectWebModuleImports, matchCapturedModules, } from "../domain/webModuleImports.js";
-import { webModuleTraceInputSchema, webModuleFileSchema, webModuleResolutionSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
+import { webModuleTraceInputSchema, webModuleFileSchema, webModuleResolutionBatchSchema, webModuleResolutionObservationSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
 import { selectedWebScriptArtifactsSchema } from "../domain/webScriptArtifacts.js";
 import { capturedWebManifestIdentity, validateSelectedWebScript, } from "./ValidateSelectedWebScript.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 const OPERATION = "trace_web_module_imports";
 const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
     importMap: z
@@ -20,12 +22,6 @@ const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
     })
         .nullable(),
 });
-const resolutionBatchSchema = z.strictObject({
-    engine: z.strictObject({ id: z.string().min(1), version: z.string().min(1) }),
-    resolutions: z.array(webModuleResolutionSchema),
-    diagnostics: z.array(z.string()),
-    rawResult: jsonObjectSchema,
-});
 const LIMITATIONS = [
     "Resolution is derived under the selected importer URL and optional import map; it does not establish that the map was installed in the captured page.",
     "Reported source URLs do not establish an inline script's document base. Select importer_url explicitly when that context differs or is unknown.",
@@ -51,8 +47,8 @@ export class WebModuleTraceService {
         ], "Web module trace cleanup failed");
     }
     async trace(rawInput, options) {
-        if (isAborted(options?.signal))
-            return err(new AnalysisCancelledError(OPERATION));
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION, { cause: options.signal.reason }));
         const parsed = webModuleTraceInputSchema.safeParse(rawInput);
         if (!parsed.success)
             return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput, {
@@ -98,8 +94,13 @@ export class WebModuleTraceService {
             .filter((reference) => reference.specifier !== null)
             .map((reference) => reference.specifier ?? "");
         let resolution = null;
+        let resolutionFailure;
         if (literals.length > 0) {
-            const execution = await this.resolver.resolve({
+            if (options?.signal?.aborted)
+                return err(new AnalysisCancelledError(OPERATION, {
+                    cause: options.signal.reason,
+                }));
+            const request = {
                 importerUrl,
                 importMap: data.importMap === null
                     ? null
@@ -108,18 +109,26 @@ export class WebModuleTraceService {
                         value: data.importMap.value,
                     },
                 specifiers: literals,
-            }, options);
-            if (!execution.ok)
-                return execution;
-            const report = resolutionBatchSchema.safeParse(execution.value);
-            if (!report.success)
-                return err(new AnalysisOutputError(OPERATION, "Resolver returned malformed or incomplete native evidence."));
-            resolution = report.data;
+            };
+            const execution = await this.resolver.resolve(request, options);
+            if (execution.ok) {
+                const report = webModuleResolutionBatchSchema.safeParse(execution.value);
+                if (!report.success)
+                    return err(new AnalysisOutputError(OPERATION, "Resolver returned malformed or incomplete native evidence."));
+                resolution = report.data;
+            }
+            else {
+                const observation = webModuleResolutionObservationSchema.safeParse(execution.error.partialObservation);
+                if (!observation.success ||
+                    !isDeepStrictEqual(observation.data.request, request) ||
+                    observation.data.batch.resolutions.length !== literals.length)
+                    return execution;
+                resolution = observation.data.batch;
+                resolutionFailure = execution.error;
+            }
             if (resolution.resolutions.length !== literals.length)
                 return err(new AnalysisOutputError(OPERATION, "Resolver did not return every selected literal specifier."));
         }
-        if (isAborted(options?.signal))
-            return err(new AnalysisCancelledError(OPERATION));
         let literalIndex = 0;
         const imports = [];
         for (const reference of syntax.imports) {
@@ -169,7 +178,7 @@ export class WebModuleTraceService {
         });
         if (!normalized.success)
             return err(new AnalysisOutputError(OPERATION, normalized.error.message));
-        return ok(createEvidence({
+        const evidence = createEvidence({
             path: data.sourceFile.path,
             sha256: data.sourceFile.sha256,
             format: "file",
@@ -192,7 +201,12 @@ export class WebModuleTraceService {
             evidenceLinks: data.manifest.source_evidence_id === null
                 ? []
                 : [data.manifest.source_evidence_id],
-        }));
+        });
+        if (resolutionFailure !== undefined) {
+            resolutionFailure.partialObservation = evidence;
+            return err(resolutionFailure);
+        }
+        return completeProviderEvidence(evidence, options?.signal);
     }
 }
 const admitContext = (value, path) => {
@@ -212,7 +226,6 @@ const admitContext = (value, path) => {
         }));
     return ok(null);
 };
-const isAborted = (signal) => signal?.aborted === true;
 const invalid = (path, message) => err(new AnalysisInputError(OPERATION, undefined, [
     { path, reason: "invalid_format", message },
 ]));

package/dist/application/WebNetworkCaptureService.js

@@ -9,6 +9,7 @@ import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js"
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
 import { inspectWebNetworkCaptureInputSchema, captureSensitiveValues, webNetworkCaptureSchema, } from "../domain/webNetworkCapture.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 const OPERATION = "inspect_web_network_capture";
 /** Shared CLI/MCP historical inspection preserves caller selection and producer record identity. */
 export class WebNetworkCaptureService {
@@ -51,8 +52,6 @@ export class WebNetworkCaptureService {
         const loaded = await this.port.inspect(input, options);
         if (!loaded.ok)
             return failure(loaded.error);
-        if (options?.signal?.aborted)
-            return failure(new AnalysisCancelledError(OPERATION));
         const report = webNetworkCaptureSchema.safeParse(loaded.value);
         if (!report.success)
             return failure(new AnalysisOutputError(OPERATION, "Capture adapter returned malformed historical evidence."));
@@ -107,7 +106,7 @@ export class WebNetworkCaptureService {
             record_ordinals: selected,
             sensitive_value_count: input.sensitive_values.length,
         });
-        return ok(createEvidence(safeSha256 === null
+        return completeProviderEvidence(createEvidence(safeSha256 === null
             ? undefined
             : {
                 path: safePath,
@@ -118,7 +117,11 @@ export class WebNetworkCaptureService {
             parameters,
             result: {
                 ...safeValue,
-                artifact: { ...value.artifact, path: safePath, sha256: safeSha256 },
+                artifact: {
+                    ...value.artifact,
+                    path: safePath,
+                    sha256: safeSha256,
+                },
                 records,
                 limitations: safeSha256 === null
                     ? [...limitations, subjectUnavailableReason]
@@ -138,6 +141,6 @@ export class WebNetworkCaptureService {
             limitations,
             ...(safeSha256 === null ? { subjectUnavailableReason } : {}),
             locations: safePath === "" ? [] : [{ kind: "artifact-path", path: safePath }],
-        }));
+        }), options?.signal);
     }
 }