rea-agents 2.0.0 → 2.2.0

package/dist/server/registerSessionRecordTools.js

@@ -0,0 +1,137 @@
+import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
+import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
+import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
+import { err, ok } from "../domain/result.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Register evidence bundle import and export tools. */
+export const registerEvidenceTools = (registration) => {
+    registerExportEvidenceTool(registration);
+    registerImportEvidenceTool(registration);
+};
+const registerExportEvidenceTool = ({ server, session, exportContract, filePolicy, permissionAuthority, }) => {
+    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
+        const parsedInput = safeParseToolInput(exportEvidenceBundleInputSchema, input, exportContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, exportContract);
+        const parsed = parsedInput.value;
+        const bundle = session.exportEvidenceBundle();
+        if (parsed.path === undefined)
+            return toCallToolResult(ok(bundle), exportContract);
+        const denied = await authorizeEvidencePath({
+            authority: permissionAuthority,
+            capability: "evidence_write",
+            path: parsed.path,
+            access: "write",
+            operationIdentity: `export_evidence:${parsed.path}`,
+        });
+        if (denied !== undefined)
+            return toCallToolResult(denied, exportContract);
+        const written = await writeEvidenceBundle(bundle, parsed.path, parsed.overwrite, filePolicy);
+        return written.ok
+            ? toCallToolResult(ok({
+                path: written.value.path,
+                bytes: written.value.bytes,
+                records: bundle.records.length,
+            }), exportContract)
+            : toCallToolResult(written, exportContract);
+    });
+};
+const registerImportEvidenceTool = ({ server, session, importContract, filePolicy, permissionAuthority, }) => {
+    server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
+        const parsedInput = safeParseToolInput(importEvidenceBundleInputSchema, input, importContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, importContract);
+        const path = parsedInput.value.path;
+        const denied = await authorizeEvidencePath({
+            authority: permissionAuthority,
+            capability: "evidence_read",
+            path,
+            access: "read",
+            operationIdentity: `import_evidence:${path}`,
+        });
+        if (denied !== undefined)
+            return toCallToolResult(denied, importContract);
+        const loaded = await readEvidenceBundle(path, filePolicy);
+        if (!loaded.ok)
+            return toCallToolResult(loaded, importContract);
+        const imported = session.importEvidenceBundle(loaded.value);
+        if (imported.ok && imported.value > 0)
+            server.sendResourceListChanged();
+        return imported.ok
+            ? toCallToolResult(ok({
+                imported: imported.value,
+                total: session.exportEvidenceBundle().records.length,
+            }), importContract)
+            : toCallToolResult(imported, importContract);
+    });
+};
+const authorizeEvidencePath = async (input) => {
+    if (input.authority === undefined)
+        return undefined;
+    const authorized = await input.authority.authorize({
+        capability: input.capability,
+        roots: [input.path],
+        executables: [],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: input.operationIdentity,
+    }, input.access);
+    return authorized.ok ? undefined : permissionFailure(authorized);
+};
+/** Register residual-unknown query and mutation tools. */
+export const registerUnknownTools = ({ server, session, contracts, }) => {
+    const listContract = contracts[14];
+    const recordContract = contracts[15];
+    const updateContract = contracts[16];
+    const verifyContract = contracts[17];
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
+        const parsed = safeParseToolInput(listUnknownsInputSchema, input, listContract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, listContract);
+        const filters = parsed.value;
+        return toCallToolResult(ok(session.listUnknowns({
+            ...(filters.status === undefined ? {} : { status: filters.status }),
+            ...(filters.severity === undefined
+                ? {}
+                : { severity: filters.severity }),
+            ...(filters.domain === undefined ? {} : { domain: filters.domain }),
+        })), listContract);
+    });
+    server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
+        const parsed = safeParseToolInput(recordUnknownInputSchema, input, recordContract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, recordContract);
+        const result = session.recordUnknown(parsed.value);
+        if (result.ok)
+            server.sendResourceListChanged();
+        return toCallToolResult(result, recordContract);
+    });
+    server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
+        const parsed = safeParseToolInput(updateUnknownInputSchema, input, updateContract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, updateContract);
+        const result = session.updateUnknown(parsed.value);
+        if (result.ok)
+            server.sendResourceListChanged();
+        return toCallToolResult(result, updateContract);
+    });
+    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => {
+        const parsed = safeParseToolInput(verifyUnknownResolutionInputSchema, input, verifyContract.name);
+        return parsed.ok
+            ? toCallToolResult(session.verifyUnknownResolution(parsed.value.unknown_id), verifyContract)
+            : toCallToolResult(parsed, verifyContract);
+    });
+};
+const permissionFailure = (failure) => {
+    if (failure.ok)
+        return err(new AnalysisProtocolError("Expected a denied permission"));
+    return err(failure.error instanceof PermissionRequiredError
+        ? failure.error
+        : new AnalysisProtocolError(failure.error.message, {
+            cause: failure.error,
+        }));
+};

package/dist/server/registerSessionStatusTool.js

@@ -6,7 +6,8 @@ import { buildCapabilityInventory } from "../application/CapabilityInventory.js"
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { safeParseToolInput } from "./toolInputValidation.js";
 /** Register the read-only provider and target status operation. */
-export const registerSessionStatusTool = (server, session, contract, startedAt, availabilityPolicy) => {
+export const registerSessionStatusTool = (options) => {
+    const { server, session, contract, startedAt, availabilityPolicy } = options;
     server.registerTool(contract.name, toolRegistrationOptions(contract), (input) => {
         const parsedInput = safeParseToolInput(binarySessionInputSchema, input, contract.name);
         if (!parsedInput.ok)
@@ -15,38 +16,108 @@ export const registerSessionStatusTool = (server, session, contract, startedAt,
         const client = server.server.getClientVersion();
         const clientCapabilities = server.server.getClientCapabilities();
         const status = session.status();
+        const statusObject = jsonObjectSchema.parse(status);
+        const toolAvailability = buildCapabilityInventory(status, availabilityPolicy());
+        const serverIdentity = createServerIdentity({
+            startedAt,
+            expected: {
+                ...(parsed.expected_package_version === undefined
+                    ? {}
+                    : { package_version: parsed.expected_package_version }),
+                ...(parsed.expected_catalog_digest === undefined
+                    ? {}
+                    : { catalog_digest: parsed.expected_catalog_digest }),
+                ...(parsed.expected_server_path === undefined
+                    ? {}
+                    : { server_path: parsed.expected_server_path }),
+            },
+            ...(client === undefined ? {} : { client }),
+            ...(server.server.getNegotiatedProtocolVersion() === undefined
+                ? {}
+                : {
+                    protocolVersion: server.server.getNegotiatedProtocolVersion(),
+                }),
+        });
         return toCallToolResult({
             ok: true,
-            value: {
-                ...jsonObjectSchema.parse(status),
-                tool_availability: buildCapabilityInventory(status, availabilityPolicy()),
-                client_features: {
+            value: projectSessionStatus({
+                input: parsed,
+                status: statusObject,
+                toolAvailability,
+                serverIdentity,
+                clientFeatures: {
                     elicitation_form: clientCapabilities?.elicitation?.form !== undefined,
                     elicitation_url: clientCapabilities?.elicitation?.url !== undefined,
                     roots: clientCapabilities?.roots !== undefined,
                     sampling: clientCapabilities?.sampling !== undefined,
                 },
-                server_identity: createServerIdentity({
-                    startedAt,
-                    expected: {
-                        ...(parsed.expected_package_version === undefined
-                            ? {}
-                            : { package_version: parsed.expected_package_version }),
-                        ...(parsed.expected_catalog_digest === undefined
-                            ? {}
-                            : { catalog_digest: parsed.expected_catalog_digest }),
-                        ...(parsed.expected_server_path === undefined
-                            ? {}
-                            : { server_path: parsed.expected_server_path }),
-                    },
-                    ...(client === undefined ? {} : { client }),
-                    ...(server.server.getNegotiatedProtocolVersion() === undefined
-                        ? {}
-                        : {
-                            protocolVersion: server.server.getNegotiatedProtocolVersion(),
-                        }),
-                }),
-            },
+            }),
         }, contract);
     });
 };
+const projectSessionStatus = (options) => {
+    if (options.input.detail === "full")
+        return jsonObjectSchema.parse({
+            view: "full",
+            ...options.status,
+            tool_availability: options.toolAvailability,
+            client_features: options.clientFeatures,
+            server_identity: options.serverIdentity,
+        });
+    const open = options.status.open === true;
+    const activeProvider = activeProviderFrom(options.status);
+    if (options.input.detail === "capabilities") {
+        const filtered = options.input.capability_family === undefined
+            ? options.toolAvailability
+            : options.toolAvailability.filter(({ surface }) => surface === options.input.capability_family);
+        const items = filtered.slice(options.input.cursor, options.input.cursor + options.input.limit);
+        const nextCursor = options.input.cursor + items.length;
+        return jsonObjectSchema.parse({
+            view: "capabilities",
+            open,
+            provider: options.status.provider,
+            active_provider: activeProvider,
+            capability_family: options.input.capability_family ?? null,
+            capabilities: {
+                items,
+                cursor: options.input.cursor,
+                limit: options.input.limit,
+                total: filtered.length,
+                next_cursor: nextCursor < filtered.length ? nextCursor : null,
+                has_more: nextCursor < filtered.length,
+            },
+        });
+    }
+    return jsonObjectSchema.parse({
+        view: "summary",
+        open,
+        provider: options.status.provider,
+        active_provider: activeProvider,
+        target: open ? targetFrom(options.status) : null,
+        alignment: options.serverIdentity.alignment,
+        recommended_actions: recommendedActions(open, options.serverIdentity.alignment.state),
+    });
+};
+const activeProviderFrom = (status) => {
+    const binding = jsonObjectSchema.safeParse(status.analysis_provider_binding);
+    return binding.success ? (binding.data.provider ?? null) : null;
+};
+const targetFrom = (status) => ({
+    path: status.path,
+    format: status.format,
+    kind: status.kind,
+    sha256: status.sha256,
+    architecture: status.architecture ?? null,
+});
+const recommendedActions = (open, alignment) => [
+    ...(alignment === "mcp_server_restart_required"
+        ? ["Restart the registered MCP server or client before continuing."]
+        : []),
+    ...(!open
+        ? [
+            "Route the supplied target directly: ASAR/JavaScript to analyze_javascript_application, packages to inventory_artifact, managed PE/CLI to inspect_managed_artifact, browser/Electron runtimes to their list-target tools, and native binaries to open_binary.",
+        ]
+        : [
+            "Continue from the active target with binary_overview or a bounded target-specific query.",
+        ]),
+];

package/dist/server/registerSessionTools.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { toCallToolResult } from "./toolResult.js";
 import { logToolExecution } from "./toolLogging.js";
 import { err, ok } from "../domain/result.js";
 import { processScenarioSchema } from "../domain/processCapture.js";
 import { captureProcessScenario } from "../application/ProcessHarness.js";
-import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
-import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
+import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "../application/AnalysisSnapshotFiles.js";
 import { AnalysisProtocolError, PermissionRequiredError, UnknownRegistryError, } from "../domain/errors.js";
 import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
@@ -21,6 +20,10 @@ import { registerInvestigationTools } from "./registerInvestigationTools.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "../contracts/sessionLifecycleInputs.js";
 import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
+import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
+import { isInputRequiredResult } from "@modelcontextprotocol/server";
+import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
+import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
 const permissionFailure = (failure) => {
     if (failure.ok)
         return err(new AnalysisProtocolError("Expected a denied permission"));
@@ -59,25 +62,19 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
     }
     return ok(null);
 };
-const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, }) => {
+const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, processCaptureElicitation, }) => {
     server.registerTool(captureContract.name, toolRegistrationOptions(captureContract), async (input, context) => {
         const parsedInput = safeParseToolInput(processScenarioSchema, input, captureContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, captureContract);
         const scenario = parsedInput.value;
         if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "process_capture",
-                roots: [scenario.working_directory, ...scenario.filesystem_roots],
-                executables: [scenario.executable],
-                environment_names: [
-                    ...Object.keys(scenario.environment),
-                    ...scenario.inherit_environment,
-                ],
-                network: scenario.network_access === "host" ? "external" : "none",
-                mount: false,
-                operation_identity: `capture_process_scenario:${scenario.executable}`,
-            }, "read");
+            const request = processCapturePermissionRequest(scenario);
+            const authorized = processCaptureElicitation === undefined
+                ? await permissionAuthority.authorize(request, "read")
+                : await authorizeProcessCaptureWithElicitation(permissionAuthority, request, context, processCaptureElicitation);
+            if (isInputRequiredResult(authorized))
+                return authorized;
             if (!authorized.ok)
                 return toCallToolResult(permissionFailure(authorized), captureContract);
         }
@@ -108,111 +105,19 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
         return toCallToolResult(ok(evidence), captureContract);
     });
 };
-const registerEvidenceTools = ({ server, session, exportContract, importContract, filePolicy, permissionAuthority, }) => {
-    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
-        const parsedInput = safeParseToolInput(exportEvidenceBundleInputSchema, input, exportContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, exportContract);
-        const parsed = parsedInput.value;
-        const bundle = session.exportEvidenceBundle();
-        if (parsed.path === undefined)
-            return toCallToolResult(ok(bundle), exportContract);
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "evidence_write",
-                roots: [parsed.path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `export_evidence:${parsed.path}`,
-            }, "write");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), exportContract);
-        }
-        const written = await writeEvidenceBundle(bundle, parsed.path, parsed.overwrite, filePolicy);
-        return written.ok
-            ? toCallToolResult(ok({
-                path: written.value.path,
-                bytes: written.value.bytes,
-                records: bundle.records.length,
-            }), exportContract)
-            : toCallToolResult(written, exportContract);
-    });
-    server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
-        const parsedInput = safeParseToolInput(importEvidenceBundleInputSchema, input, importContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, importContract);
-        const path = parsedInput.value.path;
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "evidence_read",
-                roots: [path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `import_evidence:${path}`,
-            }, "read");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), importContract);
-        }
-        const loaded = await readEvidenceBundle(path, filePolicy);
-        if (!loaded.ok)
-            return toCallToolResult(loaded, importContract);
-        const imported = session.importEvidenceBundle(loaded.value);
-        if (imported.ok && imported.value > 0)
-            server.sendResourceListChanged();
-        return imported.ok
-            ? toCallToolResult(ok({
-                imported: imported.value,
-                total: session.exportEvidenceBundle().records.length,
-            }), importContract)
-            : toCallToolResult(imported, importContract);
-    });
-};
-const registerUnknownTools = ({ server, session, contracts: [listContract, recordContract, updateContract, verifyContract], }) => {
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
-        const parsedInput = safeParseToolInput(listUnknownsInputSchema, input, listContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, listContract);
-        const filters = parsedInput.value;
-        return toCallToolResult(ok(session.listUnknowns({
-            ...(filters.status === undefined ? {} : { status: filters.status }),
-            ...(filters.severity === undefined
-                ? {}
-                : { severity: filters.severity }),
-            ...(filters.domain === undefined ? {} : { domain: filters.domain }),
-        })), listContract);
-    });
-    server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
-        const parsedInput = safeParseToolInput(recordUnknownInputSchema, input, recordContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, recordContract);
-        const recorded = session.recordUnknown(parsedInput.value);
-        if (recorded.ok)
-            server.sendResourceListChanged();
-        return toCallToolResult(recorded, recordContract);
-    });
-    server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
-        const parsedInput = safeParseToolInput(updateUnknownInputSchema, input, updateContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, updateContract);
-        const updated = session.updateUnknown(parsedInput.value);
-        if (updated.ok)
-            server.sendResourceListChanged();
-        return toCallToolResult(updated, updateContract);
-    });
-    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => {
-        const parsedInput = safeParseToolInput(verifyUnknownResolutionInputSchema, input, verifyContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, verifyContract);
-        const unknownId = parsedInput.value.unknown_id;
-        return toCallToolResult(session.verifyUnknownResolution(unknownId), verifyContract);
+const registerLifecycleTools = (registration) => {
+    const { server, session, contracts, startedAt, availabilityPolicy } = registration;
+    registerOpenLifecycleTool(registration);
+    registerCloseLifecycleTool(registration);
+    registerSessionStatusTool({
+        server,
+        session,
+        contract: contracts[2],
+        startedAt,
+        availabilityPolicy,
     });
 };
-const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFilePolicy, startedAt, availabilityPolicy, permissionAuthority, }) => {
-    const [openContract, closeContract, statusContract] = contracts;
+const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openContract], snapshotFilePolicy, permissionAuthority, }) => {
     server.registerTool(openContract.name, toolRegistrationOptions(openContract), async (input, context) => {
         const parsedInput = safeParseToolInput(openBinaryInputSchema, input, openContract.name);
         if (!parsedInput.ok)
@@ -263,54 +168,55 @@ const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFi
             }, openContract)
             : toCallToolResult(opened, openContract);
     });
+};
+const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], snapshotFilePolicy, permissionAuthority, }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input) => {
         const parsedInput = safeParseToolInput(closeBinaryInputSchema, input, closeContract.name);
         if (!parsedInput.ok)
             return toCallToolResult(parsedInput, closeContract);
         const parsed = parsedInput.value;
-        if (parsed.snapshot_path !== undefined) {
-            if (permissionAuthority !== undefined) {
-                const authorized = await permissionAuthority.authorize({
-                    capability: "snapshot_write",
-                    roots: [parsed.snapshot_path],
-                    executables: [],
-                    environment_names: [],
-                    network: "none",
-                    mount: false,
-                    operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
-                }, "write");
-                if (!authorized.ok)
-                    return toCallToolResult(permissionFailure(authorized), closeContract);
-            }
-            const snapshot = session.exportAnalysisSnapshot();
-            if (!snapshot.ok)
-                return toCallToolResult(snapshot, closeContract);
-            const written = await writeAnalysisSnapshot(snapshot.value, parsed.snapshot_path, parsed.overwrite, snapshotFilePolicy);
-            if (!written.ok)
-                return toCallToolResult(written, closeContract);
+        if (parsed.snapshot_path === undefined) {
             const closed = await logToolExecution(logger, closeContract.name, () => session.close());
             if (closed.ok)
                 server.sendToolListChanged();
-            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, closeContract);
         }
+        if (permissionAuthority !== undefined) {
+            const authorized = await permissionAuthority.authorize({
+                capability: "snapshot_write",
+                roots: [parsed.snapshot_path],
+                executables: [],
+                environment_names: [],
+                network: "none",
+                mount: false,
+                operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
+            }, "write");
+            if (!authorized.ok)
+                return toCallToolResult(permissionFailure(authorized), closeContract);
+        }
+        const snapshot = session.exportAnalysisSnapshot();
+        if (!snapshot.ok)
+            return toCallToolResult(snapshot, closeContract);
+        const written = await writeAnalysisSnapshot(snapshot.value, parsed.snapshot_path, parsed.overwrite, snapshotFilePolicy);
+        if (!written.ok)
+            return toCallToolResult(written, closeContract);
         const closed = await logToolExecution(logger, closeContract.name, () => session.close());
         if (closed.ok)
             server.sendToolListChanged();
-        return toCallToolResult(closed, closeContract);
+        return closed.ok
+            ? toCallToolResult(ok({
+                path: written.value.path,
+                bytes: written.value.bytes,
+                entries: snapshot.value.entries.length,
+            }), closeContract)
+            : toCallToolResult(closed, closeContract);
     });
-    registerSessionStatusTool(server, session, statusContract, startedAt, availabilityPolicy);
 };
 export const registerSessionTools = (server, session, logger, options = {}) => {
     const processPolicy = options.processPolicy ?? DENY_PROCESS_POLICY;
     const evidenceFilePolicy = options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY;
     const analysisSnapshotFilePolicy = options.analysisSnapshotFilePolicy ?? DENY_EVIDENCE_FILE_POLICY;
-    const [openContract, closeContract, statusContract, exportContract, importContract, captureContract, compareContract, compareArtifactsContract, compareFunctionsContract, compareBundlesContract, changedBehaviorContract, callPathContract, staticRuntimeContract, reconstructionContract, listUnknownContract, recordUnknownContract, updateUnknownContract, verifyUnknownContract,] = SESSION_TOOL_CONTRACTS;
+    const [openContract, closeContract, statusContract, exportContract, importContract, captureContract, compareContract, compareArtifactsContract, compareFunctionsContract, compareBundlesContract, changedBehaviorContract, callPathContract, staticRuntimeContract, reconstructionContract,] = SESSION_TOOL_CONTRACTS;
     registerLifecycleTools({
         server,
         session,
@@ -318,15 +224,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         contracts: [openContract, closeContract, statusContract],
         snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
-        availabilityPolicy: options.availabilityPolicy ??
-            (() => ({
-                processCaptureEnabled: processPolicy.enabled,
-                evidenceFileRoots: evidenceFilePolicy.roots.length,
-                browserObservationEnabled: false,
-                electronObservationEnabled: false,
-                javascriptReplayEnabled: false,
-                managedRuntimeEnabled: false,
-            })),
+        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, processPolicy, evidenceFilePolicy),
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
@@ -350,6 +248,9 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         ...(options.permissionAuthority === undefined
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
+        ...(options.processCaptureElicitation === undefined
+            ? {}
+            : { processCaptureElicitation: options.processCaptureElicitation }),
     });
     registerProcessComparisonTool(server, session, compareContract);
     registerArtifactComparisonTool(server, session, compareArtifactsContract);
@@ -376,11 +277,6 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
     registerUnknownTools({
         server,
         session,
-        contracts: [
-            listUnknownContract,
-            recordUnknownContract,
-            updateUnknownContract,
-            verifyUnknownContract,
-        ],
+        contracts: SESSION_TOOL_CONTRACTS,
     });
 };

package/dist/server/sessionAvailabilityPolicy.js

@@ -0,0 +1,10 @@
+/** Select configured availability reporting or the target-free defaults. */
+export const sessionAvailabilityPolicy = (configured, processPolicy, evidenceFilePolicy) => configured ??
+    (() => ({
+        processCaptureEnabled: processPolicy.enabled,
+        evidenceFileRoots: evidenceFilePolicy.roots.length,
+        browserObservationEnabled: false,
+        electronObservationEnabled: false,
+        javascriptReplayEnabled: false,
+        managedRuntimeEnabled: false,
+    }));