rea-agents 3.1.0 → 3.2.1

package/dist/server/registerSessionRecordTools.js

@@ -1,7 +1,6 @@
 import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
+import { ok } from "../domain/result.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register evidence bundle import and export tools. */
@@ -9,56 +8,11 @@ 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, }) => {
+const registerExportEvidenceTool = ({ server, session, exportContract, }) => {
     server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
         const bundle = session.exportEvidenceBundle();
-        const denied = await authorizeEvidencePath({
-            authority: permissionAuthority,
-            capability: "evidence_write",
-            path: input.path,
-            access: "write",
-            operationIdentity: `export_evidence:${input.path}`,
-        });
-        if (denied !== undefined)
-            return toCallToolResult(denied, exportContract);
-        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite, filePolicy);
+        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite);
         return written.ok
             ? toCallToolResult(ok({
                 path: written.value.path,
@@ -70,44 +24,12 @@ const registerExportEvidenceTool = ({ server, session, exportContract, filePolic
     });
 };
 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",
-                },
-            ],
-        });
-    });
+    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => toCallToolResult(ok(session.exportEvidenceBundle()), snapshotContract));
 };
-const registerImportEvidenceTool = ({ server, session, importContract, filePolicy, permissionAuthority, }) => {
+const registerImportEvidenceTool = ({ server, session, importContract, }) => {
     server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
         const path = input.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);
+        const loaded = await readEvidenceBundle(path);
         if (!loaded.ok)
             return toCallToolResult(loaded, importContract);
         const retainedUnknownRevisions = new Set(session
@@ -124,20 +46,6 @@ const registerImportEvidenceTool = ({ server, session, importContract, filePolic
     });
 };
 const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
-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. */
 const registerListUnknownsTool = ({ server, session, contracts, }) => {
     const listContract = contracts[14];
@@ -150,69 +58,24 @@ const registerListUnknownsTool = ({ server, session, contracts, }) => {
                 : { severity: filters.severity }),
             ...(filters.domain === undefined ? {} : { domain: filters.domain }),
         });
-        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,
+            items: all,
             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`,
-            })),
-        });
+        }), listContract);
     });
 };
 const registerRecordUnknownTool = ({ server, session, contracts, }) => {
     const recordContract = contracts[15];
     server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
         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);
+        return toCallToolResult(result, recordContract);
     });
 };
 const registerUpdateUnknownTool = ({ server, session, contracts, }) => {
     const updateContract = contracts[16];
     server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
         const result = session.updateUnknown(input);
-        if (result.ok)
-            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);
+        return toCallToolResult(result, updateContract);
     });
 };
 const registerVerifyUnknownTool = ({ server, session, contracts, }) => {
@@ -225,12 +88,3 @@ export const registerUnknownTools = (registration) => {
     registerUpdateUnknownTool(registration);
     registerVerifyUnknownTool(registration);
 };
-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

@@ -1,5 +1,5 @@
 import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
-import { binarySessionInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { mcpClientMetadata } from "./mcpClientMetadata.js";
@@ -32,7 +32,6 @@ export const registerSessionStatusTool = (options) => {
         return toCallToolResult({
             ok: true,
             value: projectSessionStatus({
-                input: input,
                 status: statusObject,
                 toolAvailability,
                 serverIdentity,
@@ -41,71 +40,9 @@ export const registerSessionStatusTool = (options) => {
         }, 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,
-            },
-            client_features: options.clientFeatures,
-        });
-    }
-    return jsonObjectSchema.parse({
-        view: "summary",
-        open,
-        provider: options.status.provider,
-        active_provider: activeProvider,
-        target: open ? targetFrom(options.status) : null,
-        alignment: options.serverIdentity.alignment,
-        analysis_activity: options.status.analysis_activity,
-        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 projectSessionStatus = (options) => jsonObjectSchema.parse({
+    ...options.status,
+    tool_availability: options.toolAvailability,
+    client_features: options.clientFeatures,
+    server_identity: options.serverIdentity,
 });
-const recommendedActions = (open, alignment) => [
-    ...(alignment === "mcp_server_restart_required"
-        ? ["Restart the registered MCP server or client before continuing."]
-        : []),
-    ...(!open
-        ? [
-            "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

@@ -7,9 +7,9 @@ import { createProcessCaptureEvidence } from "../application/ProcessEvidence.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 { err, ok } from "../domain/result.js";
+import { projectPermissionFailure } from "../application/PermissionFailure.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { permissionFailure } from "./permissionFailure.js";
 import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
 import { registerArtifactComparisonTool } from "./registerArtifactComparisonTool.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
@@ -21,16 +21,13 @@ import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
 import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
 import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
-import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
+import { 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);
     for (const residual of residuals) {
         const unknown = session.recordUnknown({
-            approved: true,
             question: `Was ${residual.scope} behavior fully observed during capture?`,
             severity: "medium",
             domain: `process-${residual.scope}`,
@@ -65,7 +62,7 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
             if (isInputRequiredResult(authorized))
                 return authorized;
             if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), captureContract);
+                return toCallToolResult(err(projectPermissionFailure(authorized.error)), captureContract);
         }
         const progress = mcpProgressReporter(context);
         await progress.report({
@@ -106,24 +103,11 @@ const registerLifecycleTools = (registration) => {
         availabilityPolicy,
     });
 };
-const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openContract], snapshotFilePolicy, permissionAuthority, }) => {
+const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openContract], }) => {
     server.registerTool(openContract.name, toolRegistrationOptions(openContract), async (input, context) => {
         let snapshot;
         if (input.snapshot_path !== undefined) {
-            if (permissionAuthority !== undefined) {
-                const authorized = await permissionAuthority.authorize({
-                    capability: "snapshot_read",
-                    roots: [input.snapshot_path],
-                    executables: [],
-                    environment_names: [],
-                    network: "none",
-                    mount: false,
-                    operation_identity: `open_binary:snapshot:${input.snapshot_path}`,
-                }, "read");
-                if (!authorized.ok)
-                    return toCallToolResult(permissionFailure(authorized), openContract);
-            }
-            const loaded = await readAnalysisSnapshot(input.snapshot_path, snapshotFilePolicy);
+            const loaded = await readAnalysisSnapshot(input.snapshot_path);
             if (!loaded.ok)
                 return toCallToolResult(loaded, openContract);
             snapshot = loaded.value;
@@ -161,8 +145,8 @@ const registerRecordAndReplayTools = (server, session, logger) => {
     registerReplayMachineTool(server, logger);
 };
 const registerContextTools = (server, session) => {
-    const navigationContract = SESSION_TOOL_CONTRACTS[21];
-    const addressContract = SESSION_TOOL_CONTRACTS[22];
+    const navigationContract = SESSION_TOOL_CONTRACTS[20];
+    const addressContract = SESSION_TOOL_CONTRACTS[21];
     server.registerTool(navigationContract.name, toolRegistrationOptions(navigationContract), async (input, context) => {
         return toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
     });
@@ -172,26 +156,17 @@ const registerContextTools = (server, session) => {
 };
 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,] = SESSION_TOOL_CONTRACTS;
     const snapshotContract = SESSION_TOOL_CONTRACTS[19];
-    const releaseContract = SESSION_TOOL_CONTRACTS[20];
     registerLifecycleTools({
         server,
         session,
         logger,
         contracts: [openContract, closeContract, statusContract],
-        snapshotFilePolicy: analysisSnapshotFilePolicy,
         startedAt: options.startedAt ?? new Date().toISOString(),
         availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {
             processPolicy: processPolicy(),
-            evidenceFilePolicy,
-            investigationInputRoots: options.investigationInputRoots ?? [],
         }),
-        ...(options.permissionAuthority === undefined
-            ? {}
-            : { permissionAuthority: options.permissionAuthority }),
     });
     registerEvidenceTools({
         server,
@@ -199,11 +174,6 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         exportContract,
         importContract,
         snapshotContract,
-        releaseContract,
-        filePolicy: evidenceFilePolicy,
-        ...(options.permissionAuthority === undefined
-            ? {}
-            : { permissionAuthority: options.permissionAuthority }),
     });
     registerProcessTools({
         server,
@@ -221,25 +191,14 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
     registerProcessComparisonTool(server, session, compareContract);
     registerArtifactComparisonTool(server, session, compareArtifactsContract);
     registerFunctionComparisonTool(server, session, compareFunctionsContract);
-    registerBundleComparisonTool(server, session, compareBundlesContract, evidenceFilePolicy);
+    registerBundleComparisonTool(server, session, compareBundlesContract);
     const investigationContracts = [
         changedBehaviorContract,
         callPathContract,
         staticRuntimeContract,
         reconstructionContract,
     ];
-    registerInvestigationTools(server, session, investigationContracts, {
-        evidenceFiles: evidenceFilePolicy,
-        inputRoots: options.investigationInputRoots ?? [],
-        ...(options.artifactIntegrityContinueEnabled === undefined
-            ? {}
-            : {
-                integrityContinueEnabled: options.artifactIntegrityContinueEnabled,
-            }),
-        ...(options.permissionAuthority === undefined
-            ? {}
-            : { permissionAuthority: options.permissionAuthority }),
-    });
+    registerInvestigationTools(server, session, investigationContracts);
     registerRecordAndReplayTools(server, session, logger);
     registerContextTools(server, session);
 };

package/dist/server/sessionAvailabilityPolicy.js

@@ -2,8 +2,6 @@
 export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
     (() => ({
         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,

package/dist/server/sessionEvidence.js

@@ -1,17 +1,11 @@
-import { EvidenceIntegrityError, EvidenceReferenceError, } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
-/** Resolve bounded IDs to authoritative records with exact semantic identity. */
-export const resolveSessionEvidenceIds = (session, evidenceIds, expected) => {
-    const records = [];
-    for (const evidenceId of evidenceIds) {
-        const record = session.evidenceById(evidenceId);
-        if (record === undefined)
-            return err(new EvidenceReferenceError(evidenceId, "missing", expected.operation, null));
-        if (record.operation !== expected.operation)
-            return err(new EvidenceReferenceError(evidenceId, "wrong_operation", expected.operation, record.operation));
-        if (record.predicate_type !== expected.predicate)
-            return err(new EvidenceReferenceError(evidenceId, "wrong_predicate", expected.predicate, record.predicate_type));
-        records.push(record);
+import { EvidenceIntegrityError } from "../domain/errors.js";
+import { ok } from "../domain/result.js";
+/** Record source evidence in order, stopping at the first session rejection. */
+export const recordSessionEvidenceSources = (recordEvidence, sources) => {
+    for (const source of sources) {
+        const recorded = recordEvidence?.(source);
+        if (recorded !== undefined && !recorded.ok)
+            return recorded;
     }
-    return ok(records);
+    return ok(null);
 };

package/dist/server/sessionToolPolicies.js

@@ -2,13 +2,5 @@
 export const DENY_PROCESS_POLICY = {
     status: "disabled",
 };
-/** Fail-closed evidence filesystem policy used without approved roots. */
-export const DENY_EVIDENCE_FILE_POLICY = {
-    roots: [],
-    maxBytes: 64 * 1024 * 1024,
-    maxDepth: 64,
-    maxStringLength: 1024 * 1024,
-    maxNodes: 1_000_000,
-};
 export { PROCESS_PROVIDER } from "../application/ProcessEvidence.js";
 export { ARTIFACT_COMPARISON_PROVIDER, BUNDLE_COMPARISON_PROVIDER, CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, FUNCTION_COMPARISON_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "../application/InvestigationProviders.js";

package/dist/server/toolResult.js

@@ -4,9 +4,7 @@ import { projectAnalysisError } from "../domain/errors.js";
  * Error tags and safe messages remain visible while underlying causes, process
  * output, and other potentially sensitive details stay private.
  */
-export const toCallToolResult = (result, contract, options = {}) => result.ok
-    ? successResult(result.value, contract, options)
-    : errorResult(result.error);
+export const toCallToolResult = (result, contract) => result.ok ? successResult(result.value, contract) : errorResult(result.error);
 const errorResult = (error) => {
     const projected = projectAnalysisError(error);
     const structuredContent = { error: projected };
@@ -21,42 +19,20 @@ const errorResult = (error) => {
         isError: true,
     };
 };
-const successResult = (value, contract, options) => {
-    const candidate = compactEvidence(value, options.evidenceResultProjection) ??
+const successResult = (value, contract) => {
+    const candidate = compactEvidence(value) ??
         (contract.kind === "session" ? { result: value } : value);
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(options.evidenceTextProjection === undefined
-                    ? candidate
-                    : (compactEvidence(value, options.evidenceTextProjection) ??
-                        options.evidenceTextProjection)),
+                text: JSON.stringify(candidate),
             },
-            ...(hasResourceLinks(value, contract, options)
-                ? [
-                    {
-                        type: "text",
-                        text: "Full detail is available through MCP resources/read. Copy the opaque URI exactly. In Codex, call read_mcp_resource.",
-                    },
-                ]
-                : []),
-            ...evidenceResourceLinks(value, contract.kind === "session" ||
-                options.evidenceResourcesAvailable === true),
-            ...(options.resourceLinks ?? []).map((resource) => ({
-                type: "resource_link",
-                ...resource,
-                mimeType: "application/json",
-            })),
         ],
         structuredContent: candidate,
     };
 };
-const hasResourceLinks = (value, contract, options) => options.resourceLinks !== undefined && options.resourceLinks.length > 0
-    ? true
-    : evidenceResourceLinks(value, contract.kind === "session" ||
-        options.evidenceResourcesAvailable === true).length > 0;
-const compactEvidence = (value, resultProjection) => {
+const compactEvidence = (value) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -64,27 +40,15 @@ const compactEvidence = (value, resultProjection) => {
         !/^ev_[a-f0-9]{64}$/u.test(value.evidence_id) ||
         !("normalized_result" in value))
         return undefined;
+    const evidence = value;
+    const normalizedResult = evidence.normalized_result;
+    const evidenceId = evidence.evidence_id;
+    if (normalizedResult === undefined || typeof evidenceId !== "string")
+        return undefined;
+    const inlineEvidence = Object.fromEntries(Object.entries(evidence).filter(([key]) => key !== "normalized_result"));
     return {
-        result: resultProjection ?? value.normalized_result,
-        evidence_id: value.evidence_id,
-        evidence_uri: `rea://evidence/${value.evidence_id}`,
+        result: normalizedResult,
+        evidence_id: evidenceId,
+        evidence: inlineEvidence,
     };
 };
-const evidenceResourceLinks = (value, available) => {
-    if (!available ||
-        typeof value !== "object" ||
-        value === null ||
-        Array.isArray(value) ||
-        typeof value.evidence_id !== "string" ||
-        !/^ev_[a-f0-9]{64}$/u.test(value.evidence_id))
-        return [];
-    return [
-        {
-            type: "resource_link",
-            uri: `rea://evidence/${value.evidence_id}`,
-            name: value.evidence_id,
-            description: "Session-owned Evidence v2 record",
-            mimeType: "application/json",
-        },
-    ];
-};

package/dist/serverIdentity.js

@@ -50,7 +50,6 @@ export const createServerIdentity = (input) => {
         protocol_features: {
             progress: true,
             cancellation: true,
-            evidence_resources: true,
             elicitation: false,
         },
         alignment: {
@@ -68,22 +67,3 @@ export const createServerIdentity = (input) => {
         },
     };
 };
-/** Compact identity projection for CLI summaries; MCP retains full identity. */
-export const createServerIdentitySummary = (input) => {
-    const identity = createServerIdentity(input);
-    return {
-        package: {
-            name: identity.package.name,
-            version: identity.package.version,
-        },
-        server: {
-            name: identity.server.name,
-            version: identity.server.version,
-        },
-        catalog: {
-            counts: identity.catalog.counts,
-            digests: identity.catalog.digests,
-        },
-        alignment: identity.alignment,
-    };
-};

package/install.sh

@@ -102,7 +102,7 @@ printf 'Installing %s@%s...\n' "$PACKAGE" "$version"
 npm install --global "${prefix_args[@]}" "$PACKAGE@$version" || fail "npm could not install REA. Check registry access and npm permissions, then retry."
 [[ -x "$install_bin" ]] || fail "npm completed without installing the rea command. Check the npm global bin directory and PATH, then retry."
 installed_version="$("$install_bin" --version 2>/dev/null | tr -d '[:space:]')" || fail "the installed REA version could not be read. Reinstall the requested version, then retry."
-[[ "$installed_version" == "$version" ]] || fail "installed version $installed_version does not match $version."
+[[ "$installed_version" == "$version" ]] || fail "installed version $installed_version does not match $version. Reinstall the requested version, then retry."
 
 printf 'REA %s is installed.\n' "$version"
 if [[ "$start_setup" == true && -r /dev/tty && -w /dev/tty && -t 1 ]]; then