rea-agents 6.0.0 → 6.1.0

package/dist/process/capture/ProcessCaptureLifecycle.js

@@ -434,10 +434,18 @@ export const releaseProcessResources = async (options) => {
             };
         }
         else {
+            const terminalPid = options.terminal.pid;
+            const relation = {
+                leaderPid: terminalPid,
+                processGroupId: terminalPid,
+                ...(options.sampledProcessGroupIds === undefined
+                    ? {}
+                    : { sampledProcessGroupIds: options.sampledProcessGroupIds }),
+            };
             const cleaned = await host.cleanupProcessGroup({
                 runId: options.runId,
-                leaderPid: options.terminal.pid,
-                processGroupId: options.terminal.pid,
+                leaderPid: terminalPid,
+                processGroupId: terminalPid,
                 sweepTokenOwnedProcesses: true,
                 ...(options.sampledProcessGroupIds === undefined
                     ? {}
@@ -446,14 +454,26 @@ export const releaseProcessResources = async (options) => {
                     ? {}
                     : { captureBaseline: options.captureBaseline }),
             });
+            const unverified = [...(cleaned.unverified ?? [])];
             if (!cleaned.cleaned) {
                 ownedProcessGroup = { state: "unverified", reason: cleaned.reason };
             }
             else {
-                const verified = await verifyTokenOwnedProcessesUntilSettled(() => host.verifyTokenOwnedProcesses(options.runId, undefined, options.captureBaseline));
+                const verified = await verifyTokenOwnedProcessesUntilSettled(() => host.verifyTokenOwnedProcesses(options.runId, undefined, options.captureBaseline, relation));
+                unverified.push(...(verified.unverified ?? []));
                 if (!verified.cleaned)
                     ownedProcessGroup = { state: "unverified", reason: verified.reason };
             }
+            if (unverified.length > 0)
+                ownedProcessGroup = {
+                    ...ownedProcessGroup,
+                    unverified_processes: [
+                        ...new Map(unverified.map(({ pid, diagnostic }) => [
+                            `${String(pid)}:${diagnostic}`,
+                            { pid, reason: diagnostic },
+                        ])).values(),
+                    ],
+                };
         }
     }
     let temporaryRoot = {
@@ -511,41 +531,53 @@ export const captureTerminalFrames = (options) => {
 };
 export const resolveProcessResult = (capture, executionFailure, cleanup, observations, partialContext) => {
     const cleanupFailure = cleanupReportFailure(cleanup);
-    if (cleanupFailure !== undefined) {
-        const cleanupResources = Object.entries(cleanup)
-            .filter(([, outcome]) => outcome.state === "failed" || outcome.state === "unverified")
-            .map(([resource]) => resource);
-        const executionFailureReason = describeProcessCaptureExecutionFailure(executionFailure);
-        let partialObservation;
-        if (capture !== undefined || observations !== undefined) {
-            const normalizedObservations = observations === undefined || partialContext === undefined
-                ? observations
-                : normalizePartialProcessObservations(observations, partialContext);
-            const partialPayload = capture === undefined
-                ? { observations: normalizedObservations }
-                : { capture };
-            const pendingCapture = capture === undefined
-                ? undefined
-                : {
-                    ...capture,
-                    settlement: {
+    const executionFailureReason = describeProcessCaptureExecutionFailure(executionFailure);
+    let partialObservation;
+    if ((cleanupFailure !== undefined || executionFailure !== undefined) &&
+        (capture !== undefined || observations !== undefined)) {
+        const normalizedObservations = observations === undefined || partialContext === undefined
+            ? observations
+            : normalizePartialProcessObservations(observations, partialContext);
+        if (capture === undefined) {
+            if (normalizedObservations !== undefined) {
+                const partialResult = partialProcessCaptureObservationSchema.safeParse({
+                    observations: normalizedObservations,
+                    cleanup,
+                    execution_failure: executionFailureReason ?? null,
+                });
+                if (partialResult.success)
+                    partialObservation = partialResult.data;
+            }
+        }
+        else {
+            const captureData = "cleanup" in capture
+                ? (() => {
+                    const { cleanup: _cleanup, ...data } = capture;
+                    void _cleanup;
+                    return data;
+                })()
+                : capture;
+            const settlement = cleanupFailure !== undefined
+                ? { ...capture.settlement, cleanup_outcome: "failed" }
+                : capture.settlement.state === "quiesced"
+                    ? {
                         ...capture.settlement,
-                        cleanup_outcome: "failed",
-                    },
-                };
+                        cleanup_outcome: "not_required",
+                    }
+                    : { ...capture.settlement, cleanup_outcome: "cleaned" };
             const partialResult = partialProcessCaptureObservationSchema.safeParse({
-                ...partialPayload,
-                ...(pendingCapture === undefined
-                    ? {}
-                    : {
-                        capture: Object.fromEntries(Object.entries(pendingCapture).filter(([key]) => key !== "cleanup")),
-                    }),
+                capture: { ...captureData, settlement },
                 cleanup,
                 execution_failure: executionFailureReason ?? null,
             });
             if (partialResult.success)
                 partialObservation = partialResult.data;
         }
+    }
+    if (cleanupFailure !== undefined) {
+        const cleanupResources = Object.entries(cleanup)
+            .filter(([, outcome]) => outcome.state === "failed" || outcome.state === "unverified")
+            .map(([resource]) => resource);
         throw new ProcessCaptureError(cleanupFailure, {
             cause: executionFailure,
             reason: "cleanup_incomplete",
@@ -557,20 +589,43 @@ export const resolveProcessResult = (capture, executionFailure, cleanup, observa
             cleanupReport: cleanup,
         });
     }
-    if (executionFailure instanceof ProcessCaptureError)
-        throw executionFailure;
+    if (executionFailure instanceof ProcessCaptureError) {
+        const retainedExecutionFailure = executionFailure.executionFailure ?? executionFailureReason;
+        const retainedPartialObservation = executionFailure.partialObservation ?? partialObservation;
+        throw new ProcessCaptureError(executionFailure.message, {
+            cause: executionFailure,
+            ...(executionFailure.userMessage === undefined
+                ? {}
+                : { userMessage: executionFailure.userMessage }),
+            ...(executionFailure.userCategory === undefined
+                ? {}
+                : { userCategory: executionFailure.userCategory }),
+            reason: executionFailure.reason,
+            cleanupResources: executionFailure.cleanupResources,
+            ...(retainedExecutionFailure === undefined
+                ? {}
+                : { executionFailure: retainedExecutionFailure }),
+            ...(retainedPartialObservation === undefined
+                ? {}
+                : { partialObservation: retainedPartialObservation }),
+            cleanupReport: executionFailure.cleanupReport ?? cleanup,
+        });
+    }
     if (executionFailure !== undefined) {
-        const executionFailureReason = describeProcessCaptureExecutionFailure(executionFailure);
         throw new ProcessCaptureError("process capture failed", {
             cause: executionFailure,
+            reason: "capture_failed",
             ...(executionFailureReason === undefined
                 ? {}
                 : { executionFailure: executionFailureReason }),
+            ...(partialObservation === undefined ? {} : { partialObservation }),
+            cleanupReport: cleanup,
         });
     }
     if (capture === undefined)
         throw new ProcessCaptureError("process capture produced no result");
-    if ("cleanup" in capture)
+    const unverifiedProcesses = cleanup.owned_process_group.unverified_processes;
+    if ("cleanup" in capture && unverifiedProcesses === undefined)
         return capture;
     const settlement = capture.settlement.state === "quiesced"
         ? { ...capture.settlement, cleanup_outcome: "not_required" }
@@ -579,9 +634,20 @@ export const resolveProcessResult = (capture, executionFailure, cleanup, observa
         return parseProcessCapture({
             ...capture,
             settlement,
+            residual_unknowns: [
+                ...capture.residual_unknowns,
+                ...(unverifiedProcesses ?? []).map(({ pid, reason }) => ({
+                    scope: "process",
+                    reason: `Ownership of unrelated process ${String(pid)} could not be verified; it was left untouched: ${reason}`,
+                })),
+            ],
             cleanup: {
+                ...("cleanup" in capture ? capture.cleanup : {}),
                 owned_process_group: "verified",
                 temporary_root: "removed",
+                ...(unverifiedProcesses === undefined
+                    ? {}
+                    : { unverified_processes: unverifiedProcesses }),
             },
         });
     }

package/dist/server/EvidenceMcpServer.js

@@ -0,0 +1,146 @@
+import { McpServer, isCallToolResult, isJSONRPCRequest, isJSONRPCNotification, isJSONRPCResultResponse, } from "@modelcontextprotocol/server";
+import { analysisErrorProjectionSchema } from "../contracts/errorSchemas.js";
+import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { toErrorToolResult } from "./toolResult.js";
+import { encodeToolResult, MCP_RESULT_BUDGET_BYTES, } from "./toolResultEncoding.js";
+/** Bind oversized MCP error recovery to this server's Evidence ledger. */
+export class EvidenceMcpServer extends McpServer {
+    recordEvidence;
+    constructor(info, options, recordEvidence) {
+        super(info, options);
+        this.recordEvidence = recordEvidence;
+    }
+    /** Preserve the SDK transport lifecycle while retaining oversized errors. */
+    connect(transport) {
+        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence));
+    }
+}
+class ErrorEvidenceTransport {
+    transport;
+    recordEvidence;
+    onclose;
+    onerror;
+    onmessage;
+    hasPerRequestStream;
+    pendingTools = new Map();
+    constructor(transport, recordEvidence) {
+        this.transport = transport;
+        this.recordEvidence = recordEvidence;
+        if (transport.hasPerRequestStream !== undefined)
+            this.hasPerRequestStream = transport.hasPerRequestStream;
+        transport.onmessage = (message, extra) => {
+            if (isJSONRPCRequest(message) &&
+                message.method === "tools/call" &&
+                typeof message.params?.["name"] === "string")
+                this.pendingTools.set(message.id, message.params["name"]);
+            // The SDK suppresses replies after cancellation, so send() cannot release
+            // this bookkeeping. Keep transport authentication outside retained data.
+            if (isJSONRPCNotification(message) &&
+                message.method === "notifications/cancelled") {
+                const id = message.params?.["requestId"];
+                if (typeof id === "string" || typeof id === "number")
+                    this.pendingTools.delete(id);
+            }
+            this.onmessage?.(message, extra);
+        };
+        transport.onerror = (error) => this.onerror?.(error);
+        transport.onclose = () => {
+            this.pendingTools.clear();
+            this.onclose?.();
+        };
+    }
+    get sessionId() {
+        return this.transport.sessionId;
+    }
+    set sessionId(value) {
+        this.transport.sessionId = value;
+    }
+    start() {
+        return this.transport.start();
+    }
+    async close() {
+        try {
+            await this.transport.close();
+        }
+        finally {
+            this.pendingTools.clear();
+        }
+    }
+    setProtocolVersion(version) {
+        this.transport.setProtocolVersion?.(version);
+    }
+    setSupportedProtocolVersions(versions) {
+        this.transport.setSupportedProtocolVersions?.(versions);
+    }
+    async send(message, options) {
+        const id = "id" in message &&
+            (typeof message.id === "string" || typeof message.id === "number")
+            ? message.id
+            : undefined;
+        const tool = id === undefined ? undefined : this.pendingTools.get(id);
+        try {
+            await this.transport.send(this.recoverError(message, tool), options);
+        }
+        finally {
+            if (!isJSONRPCRequest(message) && id !== undefined)
+                this.pendingTools.delete(id);
+        }
+    }
+    recoverError(message, tool) {
+        if (!isJSONRPCResultResponse(message) ||
+            !isCallToolResult(message.result) ||
+            message.result.isError !== true ||
+            message.result.structuredContent === undefined)
+            return message;
+        const structured = jsonObjectSchema.parse(message.result.structuredContent);
+        const configured = parseMcpResponseBudget(process.env.REA_MCP_MAX_RESPONSE_BYTES);
+        const budget = configured.ok && configured.value !== undefined
+            ? configured.value - 1024
+            : MCP_RESULT_BUDGET_BYTES;
+        const encoded = encodeToolResult(structured, budget);
+        if (encoded.ok)
+            return message;
+        const operation = tool ?? "mcp_tool_error";
+        const originalError = analysisErrorProjectionSchema.safeParse(structured["error"]);
+        // Retain the already projected diagnostic. Transport authentication and raw
+        // request arguments are deliberately excluded: the application owns their
+        // explicit sensitivity policy, and its error projection is authoritative.
+        const evidence = createEvidence(undefined, { id: "rea-mcp", name: "REA MCP delivery", version: "1" }, {
+            operation: "mcp_tool_error",
+            parameters: { tool_name: operation },
+            result: structured,
+            rawResult: jsonObjectSchema.parse(message.result),
+        });
+        const recorded = this.recordEvidence?.(evidence);
+        const retained = recorded !== undefined && recorded.ok;
+        const failure = new AnalysisResourceConstraintError(operation, "transport", "The tool failed, but its complete error response exceeds the MCP response budget.", {
+            boundary: "mcp-response",
+            ...(originalError.success
+                ? { original_error_code: originalError.data.code }
+                : {}),
+            result_budget_bytes: budget,
+            response_bytes_at_least: encoded.bytesAtLeast,
+            constraint: encoded.constraint,
+            ...(retained
+                ? {
+                    evidence_reference: {
+                        kind: "retained-evidence",
+                        evidence_id: evidence.evidence_id,
+                    },
+                }
+                : { retention: recorded === undefined ? "unavailable" : "failed" }),
+            ...(recorded !== undefined && !recorded.ok
+                ? { retention_error: projectAnalysisError(recorded.error) }
+                : {}),
+        }, {
+            remediationAction: retained
+                ? "Export the retained original error through export_evidence_bundle to a caller-selected path. The connection remains usable."
+                : "Configure a larger REA_MCP_MAX_RESPONSE_BYTES and matching client receive buffer, then retry. The original error could not be retained by this server.",
+        });
+        return { ...message, result: toErrorToolResult(failure) };
+    }
+}

package/dist/server/createServer.js

@@ -4,7 +4,7 @@ import { registerRecordedCrashTools } from "./registerRecordedCrashTools.js";
 import { createRecordedCrashService } from "../composition/binaryDiagnostics.js";
 import { registerBinaryDiagnosticsTools } from "./registerBinaryDiagnosticsTools.js";
 import { createBinaryLayoutService } from "../composition/binaryDiagnostics.js";
-import { McpServer } from "@modelcontextprotocol/server";
+import { EvidenceMcpServer } from "./EvidenceMcpServer.js";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
@@ -66,9 +66,6 @@ const installSessionToolAvailability = (server, session, options) => {
             firmwareExtractionEnabled: options.firmwareAnalysis !== undefined ||
                 (process.platform === "linux" &&
                     isAbsolute(process.env.REA_UNBLOB_COMMAND ?? "")),
-            androidAnalysisEnabled: options.androidAnalysis !== undefined ||
-                ((process.platform === "linux" || process.platform === "darwin") &&
-                    isAbsolute(process.env.REA_JADX_MCP_JAR ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
             javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
                 (process.platform === "linux" &&
@@ -84,7 +81,7 @@ const installSessionToolAvailability = (server, session, options) => {
         policy,
     };
 };
-const createMcpServer = (session) => new McpServer({
+const createMcpServer = (session) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -92,7 +89,9 @@ const createMcpServer = (session) => new McpServer({
     instructions: session === undefined
         ? ACTIVE_TARGET_INSTRUCTIONS
         : TARGET_FREE_INSTRUCTIONS,
-});
+}, session === undefined
+    ? undefined
+    : (evidence) => session.recordEvidence(evidence));
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -102,6 +101,7 @@ export const createServer = (analysis, session, options = {}) => {
     const startedAt = new Date().toISOString();
     const logger = options.logger ?? silentLogger;
     const server = createMcpServer(session);
+    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
     const availability = installSessionToolAvailability(server, session, options);
     const toolLogger = logger.child({ layer: "server" });
     const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
@@ -117,7 +117,6 @@ export const createServer = (analysis, session, options = {}) => {
         recordEvidenceWithUnknown,
     };
     registerBinaryAnalysisTools(toolContext);
-    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
     const previousOnclose = server.server.onclose;
     server.server.onclose = () => {
         previousOnclose?.();
@@ -150,6 +149,7 @@ export const createServer = (analysis, session, options = {}) => {
             ...(availability === undefined
                 ? {}
                 : { availabilityPolicy: availability.policy }),
+            androidAnalysisAvailability: (signal) => android.inspectAvailability(signal),
             startedAt,
         });
     }
@@ -158,7 +158,8 @@ export const createServer = (analysis, session, options = {}) => {
 const createSessionRecorders = (server, session) => ({
     evidenceById: session === undefined
         ? undefined
-        : (evidenceId) => session.evidenceById(evidenceId),
+        : (evidenceId) => session.evidenceForAnalysis?.(evidenceId) ??
+            session.evidenceById(evidenceId),
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
         ? undefined
@@ -187,6 +188,12 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
     registerEnhancedTools(server, analysis, {
         ...analysisOptions,
         analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
+        allowsSnapshotReplay: session === undefined
+            ? undefined
+            : (operation) => session.allowsSnapshotReplay(operation),
+        recordWorkflowSnapshot: session === undefined
+            ? undefined
+            : (input) => session.recordWorkflowSnapshot(input),
     });
     const evidenceOptions = { logger, activeTarget, recordEvidence };
     registerNativeTools(server, analysis, evidenceOptions);

package/dist/server/registerAndroidTools.js

@@ -2,7 +2,7 @@ import { AndroidAnalysisService } from "../application/android/AndroidAnalysisSe
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind Android handlers to their exact named contracts through shared workflows. */
 export const registerAndroidTools = (server, service, logger, recordEvidence) => {
     const handler = (contract) => {
@@ -12,9 +12,7 @@ export const registerAndroidTools = (server, service, logger, recordEvidence) =>
             if (!result.ok)
                 return toCallToolResult(result, contract);
             const recorded = recordEvidence?.(result.value);
-            return recorded !== undefined && !recorded.ok
-                ? toCallToolResult(recorded, contract)
-                : toCallToolResult(result, contract);
+            return toEvidenceToolResult(result.value, contract, recorded);
         };
     };
     const packageContract = toolContract("inspect_android_package");

package/dist/server/registerApplicationTools/helpers.js

@@ -1,12 +1,10 @@
 import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { toCallToolResult } from "../toolResult.js";
+import { toEvidenceToolResult } from "../toolResult.js";
 export const recordResult = (options, contract, evidence, unknownKind) => {
     const recorded = unknownKind === undefined
         ? options.recordEvidence?.(evidence)
         : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
-    if (recorded !== undefined && !recorded.ok)
-        return toCallToolResult(recorded, contract);
-    return toCallToolResult({ ok: true, value: evidence }, contract);
+    return toEvidenceToolResult(evidence, contract, recorded);
 };
 const unknownRegistration = (evidence, kind) => ({
     question: kind === "application-version-comparison"

package/dist/server/registerArtifactComparisonTool.js

@@ -6,7 +6,7 @@ import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -39,18 +39,22 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status)), contract);
+        return toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status, evidence.evidence_id)));
     });
 };
-const artifactUnknownInput = (left, right, status) => {
-    if (status === "unchanged" || left.evidence_id === right.evidence_id)
+const artifactUnknownInput = (left, right, status, comparisonEvidenceId) => {
+    if (status === "unchanged")
         return undefined;
+    const contradictory = (status === "changed" || status === "contradiction") &&
+        left.evidence_id !== right.evidence_id;
     return {
-        question: `Artifact comparison is ${status}`,
+        question: `Artifact comparison is ${status} (comparison ${comparisonEvidenceId})`,
         severity: status === "unknown" || status === "truncated" ? "high" : "medium",
         domain: "artifact-comparison",
-        supporting_evidence_ids: [left.evidence_id],
-        contradicting_evidence_ids: [right.evidence_id],
+        supporting_evidence_ids: contradictory
+            ? [left.evidence_id]
+            : [...new Set([left.evidence_id, right.evidence_id])],
+        contradicting_evidence_ids: contradictory ? [right.evidence_id] : [],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,

package/dist/server/registerBinaryDiagnosticsTools.js

@@ -1,7 +1,7 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind offline layout inspection to its named contract and session Evidence owner. */
 export const registerBinaryDiagnosticsTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_binary_layout");
@@ -10,8 +10,6 @@ export const registerBinaryDiagnosticsTools = (server, service, logger, recordEv
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerBrowserScenarioTool.js

@@ -5,7 +5,7 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register the browser scenario tool with execution-time provider diagnostics. */
 export const registerBrowserScenarioTool = (server, options) => {
     const contract = toolContract("capture_browser_scenario");
@@ -19,8 +19,6 @@ export const registerBrowserScenarioTool = (server, options) => {
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult({ ok: true, value: result.value }, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerBrowserTools.js

@@ -7,7 +7,7 @@ import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register browser tools with execution-time provider diagnostics. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerBrowserTools = (server, options) => {
@@ -56,7 +56,5 @@ const runBrowserTool = async (options, contract, request, execute) => {
 };
 const evidenceResult = (options, contract, evidence) => {
     const recorded = options.recordEvidence?.(evidence);
-    return recorded !== undefined && !recorded.ok
-        ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract);
+    return toEvidenceToolResult(evidence, contract, recorded);
 };

package/dist/server/registerBundleComparisonTool.js

@@ -3,11 +3,10 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { compareBundles } from "../domain/bundleComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { ok } from "../domain/result.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register canonical Evidence bundle comparison. */
 export const registerBundleComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -37,6 +36,6 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
         });
         const recorded = session.recordEvidence(evidence);
-        return toCallToolResult(recorded.ok ? ok(evidence) : recorded, contract);
+        return toEvidenceToolResult(evidence, contract, recorded);
     });
 };

package/dist/server/registerCloseLifecycleTool.js

@@ -1,6 +1,5 @@
-import { writeAnalysisSnapshot } from "../application/binary/AnalysisSnapshotFiles.js";
-import { ok } from "../domain/result.js";
 import { reportLifecycleEnd, reportLifecycleStart, } from "./lifecycleProgress.js";
+import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -9,27 +8,18 @@ import { toCallToolResult } from "./toolResult.js";
 export const registerCloseLifecycleTool = ({ server, session, logger, closeContract, }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input, context) => {
         const progress = mcpProgressReporter(context);
-        if (input.snapshot_path === undefined) {
+        const snapshotPath = input.snapshot_path;
+        if (snapshotPath === undefined) {
             await reportLifecycleStart(progress, closeContract.name);
             const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
             return toCallToolResult(closed, closeContract);
         }
-        const snapshot = session.exportAnalysisSnapshot();
-        if (!snapshot.ok)
-            return toCallToolResult(snapshot, closeContract);
-        const written = await writeAnalysisSnapshot(snapshot.value, input.snapshot_path, input.overwrite);
-        if (!written.ok)
-            return toCallToolResult(written, closeContract);
-        await reportLifecycleStart(progress, closeContract.name, "snapshot written; closing provider");
-        const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
+        await reportLifecycleStart(progress, closeContract.name, "saving snapshot; closing provider");
+        const closed = await logToolExecution(logger, closeContract.name, () => session.closeWithSnapshot(snapshotPath, input.overwrite, {
+            progress,
+        }));
         await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-        return closed.ok
-            ? toCallToolResult(ok({
-                path: written.value.path,
-                bytes: written.value.bytes,
-                entries: snapshot.value.entries.length,
-            }), closeContract)
-            : toCallToolResult(closed, closeContract);
+        return toCallToolResult(closed.ok ? ok({ ...closed.value }) : closed, closeContract);
     });
 };

package/dist/server/registerElectronTools.js

@@ -9,7 +9,7 @@ import { inspectElectronPageInputSchema } from "../domain/javascript/electronObs
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register Electron tools even when a provider is absent. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerElectronTools = (server, options) => {
@@ -55,7 +55,5 @@ const runElectronTool = async (options, contract, request, execute) => {
 };
 const evidenceResult = (options, contract, evidence) => {
     const recorded = options.recordEvidence?.(evidence);
-    return recorded !== undefined && !recorded.ok
-        ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract);
+    return toEvidenceToolResult(evidence, contract, recorded);
 };