rea-agents 2.5.0 → 3.1.0

package/dist/server/registerReconstructionObligationLedgerResource.js

@@ -4,13 +4,6 @@ import { reconstructionObligationLedgerPageSchema } from "../domain/reconstructi
 export const registerReconstructionObligationLedgerResource = (server, session) => {
     server.registerResource("reconstruction-obligation-ledger-page", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-obligation-ledger", {
         list: undefined,
-        complete: {
-            evidenceId: (prefix) => session
-                .exportEvidenceBundle()
-                .records.filter(({ predicate_type: predicateType }) => predicateType === "rea.reconstruction-obligation-ledger/v1")
-                .map(({ evidence_id: evidenceId }) => evidenceId)
-                .filter((evidenceId) => evidenceId.startsWith(prefix)),
-        },
     }), {
         title: "Reconstruction obligation ledger page",
         description: "One deterministic Evidence v2-backed obligation page with full-ledger closure digest and summaries.",

package/dist/server/registerReconstructionReadinessResource.js

@@ -4,13 +4,6 @@ import { reconstructionReadinessReportSchema } from "../domain/reconstructionRea
 export const registerReconstructionReadinessResource = (server, session) => {
     server.registerResource("reconstruction-readiness-report", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-readiness-report", {
         list: undefined,
-        complete: {
-            evidenceId: (prefix) => session
-                .exportEvidenceBundle()
-                .records.filter(({ predicate_type: predicateType }) => predicateType === "rea.reconstruction-readiness-report/v1")
-                .map(({ evidence_id: evidenceId }) => evidenceId)
-                .filter((evidenceId) => evidenceId.startsWith(prefix)),
-        },
     }), {
         title: "Reconstruction readiness report",
         description: "Full deterministic nine-stage conformance report and replay identity.",

package/dist/server/registerReplayMachineTool.js

@@ -1,20 +1,14 @@
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { replayMachineRunInputSchema, runReplayMachine, } from "../domain/replayMachineRun.js";
+import { runReplayMachine } from "../domain/replayMachineRun.js";
 import { ok } from "../domain/result.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { logToolExecution } from "./toolLogging.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-const contract = SESSION_TOOL_CONTRACTS.find(({ name }) => name === "run_replay_machine");
-if (contract === undefined)
-    throw new TypeError("Missing run_replay_machine tool contract");
+import { toCallToolResult } from "./toolResult.js";
+const contract = SESSION_TOOL_CONTRACTS[18];
 /** Register direct execution-free finite replay-machine evaluation. */
 export const registerReplayMachineTool = (server, logger) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = safeParseToolInput(replayMachineRunInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(parsed.value))));
+        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(input))));
         return toCallToolResult(result, contract);
     });
 };

package/dist/server/registerSessionRecordTools.js

@@ -1,50 +1,103 @@
 import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
-import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
+import { SESSION_TOOL_CONTRACTS } 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);
+    registerSnapshotEvidenceTool(registration);
+    registerReleaseEvidenceTool(registration);
+};
+const registerReleaseEvidenceTool = ({ server, session, releaseContract, permissionAuthority, }) => {
+    server.registerTool(releaseContract.name, toolRegistrationOptions(releaseContract), async (input) => {
+        const denied = await authorizeEvidenceWrite({
+            authority: permissionAuthority,
+            operationIdentity: `release_evidence:${input.bundle_digest}`,
+        });
+        if (denied !== undefined)
+            return toCallToolResult(denied, releaseContract);
+        const released = session.releaseEvidenceBundle(input.bundle_digest);
+        if (released)
+            void server.server
+                .sendResourceUpdated({
+                uri: `rea://evidence-bundle/${input.bundle_digest}`,
+            })
+                .catch(() => undefined);
+        return toCallToolResult(ok({
+            bundle_digest: input.bundle_digest,
+            released,
+        }), releaseContract);
+    });
+};
+const authorizeEvidenceWrite = async ({ authority, operationIdentity, }) => {
+    if (authority === undefined)
+        return undefined;
+    const authorized = await authority.authorize({
+        capability: "evidence_write",
+        roots: [],
+        executables: [],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: operationIdentity,
+    }, "write");
+    return authorized.ok ? undefined : permissionFailure(authorized);
 };
 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,
+            path: input.path,
             access: "write",
-            operationIdentity: `export_evidence:${parsed.path}`,
+            operationIdentity: `export_evidence:${input.path}`,
         });
         if (denied !== undefined)
             return toCallToolResult(denied, exportContract);
-        const written = await writeEvidenceBundle(bundle, parsed.path, parsed.overwrite, filePolicy);
+        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite, filePolicy);
         return written.ok
             ? toCallToolResult(ok({
                 path: written.value.path,
                 bytes: written.value.bytes,
                 records: bundle.records.length,
+                unknowns: bundle.unknowns.length,
             }), exportContract)
             : toCallToolResult(written, exportContract);
     });
 };
+const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) => {
+    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => {
+        const snapshot = session.snapshotEvidenceBundle();
+        if (!snapshot.ok)
+            return toCallToolResult(snapshot, snapshotContract);
+        const value = {
+            bundle_digest: snapshot.value.bundleDigest,
+            bundle_version: snapshot.value.bundleVersion,
+            bytes: snapshot.value.bytes,
+            records: snapshot.value.records,
+            unknowns: snapshot.value.unknowns,
+            scope: snapshot.value.scope,
+            survives_session: snapshot.value.survivesSession,
+            bundle_uri: snapshot.value.uri,
+        };
+        return toCallToolResult(ok(value), snapshotContract, {
+            resourceLinks: [
+                {
+                    uri: snapshot.value.uri,
+                    name: snapshot.value.bundleDigest,
+                    description: "Immutable session-retained Evidence v2 bundle",
+                },
+            ],
+        });
+    });
+};
 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 path = input.path;
         const denied = await authorizeEvidencePath({
             authority: permissionAuthority,
             capability: "evidence_read",
@@ -57,17 +110,20 @@ const registerImportEvidenceTool = ({ server, session, importContract, filePolic
         const loaded = await readEvidenceBundle(path, filePolicy);
         if (!loaded.ok)
             return toCallToolResult(loaded, importContract);
+        const retainedUnknownRevisions = new Set(session
+            .exportEvidenceBundle()
+            .unknowns.map((unknown) => unknownRevisionKey(unknown)));
         const imported = session.importEvidenceBundle(loaded.value);
-        if (imported.ok && imported.value > 0)
-            server.sendResourceListChanged();
         return imported.ok
             ? toCallToolResult(ok({
                 imported: imported.value,
+                unknowns_added: loaded.value.unknowns.filter((unknown) => !retainedUnknownRevisions.has(unknownRevisionKey(unknown))).length,
                 total: session.exportEvidenceBundle().records.length,
             }), importContract)
             : toCallToolResult(imported, importContract);
     });
 };
+const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
 const authorizeEvidencePath = async (input) => {
     if (input.authority === undefined)
         return undefined;
@@ -83,49 +139,92 @@ const authorizeEvidencePath = async (input) => {
     return authorized.ok ? undefined : permissionFailure(authorized);
 };
 /** Register residual-unknown query and mutation tools. */
-export const registerUnknownTools = ({ server, session, contracts, }) => {
+const registerListUnknownsTool = ({ 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({
+        const filters = input;
+        const all = session.listUnknowns({
             ...(filters.status === undefined ? {} : { status: filters.status }),
             ...(filters.severity === undefined
                 ? {}
                 : { severity: filters.severity }),
             ...(filters.domain === undefined ? {} : { domain: filters.domain }),
-        })), listContract);
+        });
+        const items = all
+            .slice(filters.offset, filters.offset + filters.limit)
+            .map((unknown) => ({
+            unknown,
+            uri: `rea://unknown/${unknown.unknown_id}`,
+        }));
+        const nextOffset = filters.offset + items.length < all.length
+            ? filters.offset + items.length
+            : null;
+        return toCallToolResult(ok({
+            items,
+            offset: filters.offset,
+            limit: filters.limit,
+            total: all.length,
+            next_offset: nextOffset,
+            has_more: nextOffset !== null,
+        }), listContract, {
+            resourceLinks: items.map((unknown) => ({
+                uri: unknown.uri,
+                name: unknown.unknown.unknown_id,
+                description: `Current ${unknown.unknown.status} residual unknown revision`,
+            })),
+        });
     });
+};
+const registerRecordUnknownTool = ({ server, session, contracts, }) => {
+    const recordContract = contracts[15];
     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);
+        const result = session.recordUnknown(input);
+        return result.ok
+            ? toCallToolResult(result, recordContract, {
+                resourceLinks: [
+                    {
+                        uri: `rea://unknown/${result.value.unknown_id}`,
+                        name: result.value.unknown_id,
+                        description: "Current residual unknown head",
+                    },
+                ],
+            })
+            : toCallToolResult(result, recordContract);
     });
+};
+const registerUpdateUnknownTool = ({ server, session, contracts, }) => {
+    const updateContract = contracts[16];
     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);
+        const result = session.updateUnknown(input);
         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);
+            void server.server
+                .sendResourceUpdated({
+                uri: `rea://unknown/${result.value.unknown_id}`,
+            })
+                .catch(() => undefined);
+        return result.ok
+            ? toCallToolResult(result, updateContract, {
+                resourceLinks: [
+                    {
+                        uri: `rea://unknown/${result.value.unknown_id}`,
+                        name: result.value.unknown_id,
+                        description: "Updated residual unknown head",
+                    },
+                ],
+            })
+            : toCallToolResult(result, updateContract);
     });
 };
+const registerVerifyUnknownTool = ({ server, session, contracts, }) => {
+    const verifyContract = contracts[17];
+    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => toCallToolResult(session.verifyUnknownResolution(input.unknown_id), verifyContract));
+};
+export const registerUnknownTools = (registration) => {
+    registerListUnknownsTool(registration);
+    registerRecordUnknownTool(registration);
+    registerUpdateUnknownTool(registration);
+    registerVerifyUnknownTool(registration);
+};
 const permissionFailure = (failure) => {
     if (failure.ok)
         return err(new AnalysisProtocolError("Expected a denied permission"));

package/dist/server/registerSessionStatusTool.js

@@ -1,53 +1,38 @@
+import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
 import { binarySessionInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
-import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
+import { mcpClientMetadata } from "./mcpClientMetadata.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register the read-only provider and target status operation. */
 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)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const client = server.server.getClientVersion();
-        const clientCapabilities = server.server.getClientCapabilities();
-        const clientFeatures = {
-            elicitation_form: clientCapabilities?.elicitation?.form !== undefined,
-            elicitation_url: clientCapabilities?.elicitation?.url !== undefined,
-            roots: clientCapabilities?.roots !== undefined,
-            sampling: clientCapabilities?.sampling !== undefined,
-        };
+    server.registerTool(contract.name, toolRegistrationOptions(contract), (input, context) => {
+        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context);
         const status = session.status();
         const statusObject = jsonObjectSchema.parse(status);
         const toolAvailability = buildCapabilityInventory(status, availabilityPolicy(), clientFeatures);
         const serverIdentity = createServerIdentity({
             startedAt,
             expected: {
-                ...(parsed.expected_package_version === undefined
+                ...(input.expected_package_version === undefined
                     ? {}
-                    : { package_version: parsed.expected_package_version }),
-                ...(parsed.expected_catalog_digest === undefined
+                    : { package_version: input.expected_package_version }),
+                ...(input.expected_catalog_digest === undefined
                     ? {}
-                    : { catalog_digest: parsed.expected_catalog_digest }),
-                ...(parsed.expected_server_path === undefined
+                    : { catalog_digest: input.expected_catalog_digest }),
+                ...(input.expected_server_path === undefined
                     ? {}
-                    : { server_path: parsed.expected_server_path }),
+                    : { server_path: input.expected_server_path }),
             },
             ...(client === undefined ? {} : { client }),
-            ...(server.server.getNegotiatedProtocolVersion() === undefined
-                ? {}
-                : {
-                    protocolVersion: server.server.getNegotiatedProtocolVersion(),
-                }),
+            ...(protocolVersion === undefined ? {} : { protocolVersion }),
         });
         return toCallToolResult({
             ok: true,
             value: projectSessionStatus({
-                input: parsed,
+                input: input,
                 status: statusObject,
                 toolAvailability,
                 serverIdentity,
@@ -118,7 +103,7 @@ const recommendedActions = (open, alignment) => [
         : []),
     ...(!open
         ? [
-            "Route the supplied target directly: ASAR/JavaScript to analyze_javascript_application, unfamiliar packages to inspect_artifact, managed PE/CLI to inspect_managed_artifact, browser/Electron runtimes to their list-target tools, and native binaries to open_binary.",
+            "For a supplied target, route by format: ASAR/JavaScript to analyze_javascript_application; archive/package to open_binary(path), then inspect_artifact or inventory_artifact on the active target; managed PE/CLI to inspect_managed_artifact; browser/Electron runtimes to their list-target tools; 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,32 +1,30 @@
 import { z } from "zod";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
-import { logToolExecution } from "./toolLogging.js";
-import { ok } from "../domain/result.js";
-import { processScenarioSchema } from "../domain/processCapture.js";
-import { captureProcessScenario } from "../application/ProcessHarness.js";
-import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
+import { isInputRequiredResult } from "@modelcontextprotocol/server";
+import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.js";
 import { readAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
-import { UnknownRegistryError } from "../domain/errors.js";
-import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
+import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
 import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js";
-import { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
+import { captureProcessScenario } from "../application/ProcessHarness.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { UnknownRegistryError } from "../domain/errors.js";
+import { ok } from "../domain/result.js";
+import { mcpProgressReporter } from "./mcpProgress.js";
+import { permissionFailure } from "./permissionFailure.js";
+import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
 import { registerArtifactComparisonTool } from "./registerArtifactComparisonTool.js";
-import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
+import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
+import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
 import { registerInvestigationTools } from "./registerInvestigationTools.js";
-import { 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 { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
 import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
+import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
+import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
-import { permissionFailure } from "./permissionFailure.js";
-import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
+import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
 const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) => {
     if (scenario.unknown_registry_approved !== true)
         return ok(null);
@@ -58,10 +56,7 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
 };
 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;
+        const scenario = input;
         if (permissionAuthority !== undefined) {
             const request = processCapturePermissionRequest(scenario);
             const authorized = processCaptureElicitation === undefined
@@ -79,7 +74,7 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
             total: 1,
             message: "started",
         });
-        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, processPolicy, context.mcpReq.signal));
+        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, processPolicy(), context.mcpReq.signal));
         await progress.report({
             phase: captureContract.name,
             completed: 1,
@@ -113,39 +108,33 @@ const registerLifecycleTools = (registration) => {
 };
 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)
-            return toCallToolResult(parsedInput, openContract);
-        const parsed = parsedInput.value;
         let snapshot;
-        if (parsed.snapshot_path !== undefined) {
+        if (input.snapshot_path !== undefined) {
             if (permissionAuthority !== undefined) {
                 const authorized = await permissionAuthority.authorize({
                     capability: "snapshot_read",
-                    roots: [parsed.snapshot_path],
+                    roots: [input.snapshot_path],
                     executables: [],
                     environment_names: [],
                     network: "none",
                     mount: false,
-                    operation_identity: `open_binary:snapshot:${parsed.snapshot_path}`,
+                    operation_identity: `open_binary:snapshot:${input.snapshot_path}`,
                 }, "read");
                 if (!authorized.ok)
                     return toCallToolResult(permissionFailure(authorized), openContract);
             }
-            const loaded = await readAnalysisSnapshot(parsed.snapshot_path, snapshotFilePolicy);
+            const loaded = await readAnalysisSnapshot(input.snapshot_path, snapshotFilePolicy);
             if (!loaded.ok)
                 return toCallToolResult(loaded, openContract);
             snapshot = loaded.value;
         }
-        const opened = await logToolExecution(logger, openContract.name, () => session.open(parsed.path, {
+        const opened = await logToolExecution(logger, openContract.name, () => session.open(input.path, {
             signal: context.mcpReq.signal,
-            ...(parsed.provider_id === undefined
+            ...(input.provider_id === undefined
                 ? {}
-                : { providerId: parsed.provider_id }),
+                : { providerId: input.provider_id }),
             ...(snapshot === undefined ? {} : { snapshot }),
         }));
-        if (opened.ok)
-            server.sendToolListChanged();
         return opened.ok
             ? toCallToolResult({
                 ok: true,
@@ -171,11 +160,23 @@ const registerRecordAndReplayTools = (server, session, logger) => {
     });
     registerReplayMachineTool(server, logger);
 };
+const registerContextTools = (server, session) => {
+    const navigationContract = SESSION_TOOL_CONTRACTS[21];
+    const addressContract = SESSION_TOOL_CONTRACTS[22];
+    server.registerTool(navigationContract.name, toolRegistrationOptions(navigationContract), async (input, context) => {
+        return toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
+    });
+    server.registerTool(addressContract.name, toolRegistrationOptions(addressContract), async (input, context) => {
+        return toCallToolResult(await inspectAddressContext(session, input, context.mcpReq.signal), addressContract);
+    });
+};
 export const registerSessionTools = (server, session, logger, options = {}) => {
-    const processPolicy = options.processPolicy ?? DENY_PROCESS_POLICY;
+    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,] = SESSION_TOOL_CONTRACTS;
+    const snapshotContract = SESSION_TOOL_CONTRACTS[19];
+    const releaseContract = SESSION_TOOL_CONTRACTS[20];
     registerLifecycleTools({
         server,
         session,
@@ -184,7 +185,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
         availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {
-            processPolicy,
+            processPolicy: processPolicy(),
             evidenceFilePolicy,
             investigationInputRoots: options.investigationInputRoots ?? [],
         }),
@@ -197,6 +198,8 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         session,
         exportContract,
         importContract,
+        snapshotContract,
+        releaseContract,
         filePolicy: evidenceFilePolicy,
         ...(options.permissionAuthority === undefined
             ? {}
@@ -238,4 +241,5 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
             : { permissionAuthority: options.permissionAuthority }),
     });
     registerRecordAndReplayTools(server, session, logger);
+    registerContextTools(server, session);
 };

package/dist/server/sessionAvailabilityPolicy.js

@@ -1,12 +1,13 @@
 /** Select configured availability reporting or the target-free defaults. */
 export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
     (() => ({
-        processCaptureEnabled: defaults.processPolicy.enabled,
+        processCaptureEnabled: defaults.processPolicy.status === "enabled",
         evidenceFileRoots: defaults.evidenceFilePolicy.roots.length,
         investigationInputRoots: defaults.investigationInputRoots.length,
         browserObservationEnabled: defaults.optionalFeatures?.browserObservationEnabled ?? false,
         browserScenarioEnabled: defaults.optionalFeatures?.browserScenarioEnabled ?? false,
         electronObservationEnabled: defaults.optionalFeatures?.electronObservationEnabled ?? false,
+        electronAutomationEnabled: defaults.optionalFeatures?.electronAutomationEnabled ?? false,
         v8InspectorObservationEnabled: defaults.optionalFeatures?.v8InspectorObservationEnabled ?? false,
         javascriptReplayEnabled: defaults.optionalFeatures?.javascriptReplayEnabled ?? false,
         managedRuntimeEnabled: defaults.optionalFeatures?.managedRuntimeEnabled ?? false,

package/dist/server/sessionToolPolicies.js

@@ -1,10 +1,6 @@
 /** Fail-closed process policy used when operator configuration is absent. */
 export const DENY_PROCESS_POLICY = {
-    enabled: false,
-    executableRoots: [],
-    workingRoots: [],
-    allowedEnvironment: [],
-    allowExternalNetwork: false,
+    status: "disabled",
 };
 /** Fail-closed evidence filesystem policy used without approved roots. */
 export const DENY_EVIDENCE_FILE_POLICY = {