rea-agents 3.1.0 → 3.2.1

package/dist/server/registerEnhancedTools.js

@@ -10,9 +10,9 @@ import { toCallToolResult } from "./toolResult.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerEnhancedTools = (server, analysis, options) => {
-    const [swiftClasses, objcClasses, objcProtocols, batchDecompile, callGraph, swiftTypes, xrefsToName, binaryOverview, analyzeFunction, inspectNativeApi, traceFeature, codeForString, traceCallPath,] = ENHANCED_TOOL_CONTRACTS;
-    server.registerTool(swiftClasses.name, toolRegistrationOptions(swiftClasses), (input, context) => executeEnhancedTool(analysis, options, swiftClasses, {
-        validatedCall: { name: "swift_classes", input },
+    const [nativeDispatchMetadata, objcClasses, objcProtocols, batchDecompile, callGraph, swiftTypes, xrefsToName, binaryOverview, analyzeFunction, inspectNativeApi, traceFeature, codeForString, traceCallPath, traceNativeUiAction,] = ENHANCED_TOOL_CONTRACTS;
+    server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(analysis, options, nativeDispatchMetadata, {
+        validatedCall: { name: "inspect_native_dispatch_metadata", input },
         context,
     }));
     server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(analysis, options, objcClasses, {
@@ -63,6 +63,10 @@ export const registerEnhancedTools = (server, analysis, options) => {
         validatedCall: { name: "trace_call_path", input },
         context,
     }));
+    server.registerTool(traceNativeUiAction.name, toolRegistrationOptions(traceNativeUiAction), (input, context) => executeEnhancedTool(analysis, options, traceNativeUiAction, {
+        validatedCall: { name: "trace_native_ui_action", input },
+        context,
+    }));
 };
 const executeEnhancedTool = async (analysis, registration, contract, request) => {
     const { validatedCall, context } = request;
@@ -111,28 +115,24 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
             return toCallToolResult(recorded, contract);
         const unknowns = recordWorkflowUnknowns({
             name,
-            input: parameters,
             result: result.value,
             evidenceId: evidence.evidence_id,
             recordUnknown: registration.recordUnknown,
         });
         if (!unknowns.ok)
             return toCallToolResult(unknowns, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult({ ok: true, value: evidence }, contract);
     }
     return toCallToolResult(result, contract);
 };
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
-const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown, }) => {
+const recordWorkflowUnknowns = ({ name, result, evidenceId, recordUnknown, }) => {
     if (![
         "trace_feature",
         "find_code_for_string",
         "trace_call_path",
         "inspect_native_api",
     ].includes(name) ||
-        input.unknown_registry_approved !== true ||
         recordUnknown === undefined ||
         typeof result !== "object" ||
         result === null ||
@@ -143,7 +143,6 @@ const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown
         if (typeof question !== "string")
             continue;
         const recorded = recordUnknown({
-            approved: true,
             question,
             severity: "medium",
             domain: name === "inspect_native_api" ? "native-api" : "control-flow",
@@ -157,7 +156,7 @@ const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown
                     operation: name,
                     rationale: name === "inspect_native_api"
                         ? "Confirm the unsupported boundary with a capable provider or ABI probe."
-                        : "Continue with a larger bounded budget.",
+                        : "Continue with a focused query or another available provider.",
                 },
             ],
             relationships: [],

package/dist/server/registerEvidenceTools.js

@@ -1,4 +1,4 @@
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { projectPermissionFailure } from "../application/PermissionFailure.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { err } from "../domain/result.js";
@@ -6,7 +6,8 @@ import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
-/** Register provider-backed contracts that return atomic Evidence v2 observations. */
+import { artifactExtractionPermissionRequest, createArtifactExtractionDestination, } from "../application/ArtifactExtractionDestination.js";
+/** Register provider-backed contracts that return atomic Evidence observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
     for (const contract of contracts) {
         server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -18,19 +19,21 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 message: "started",
             });
             const parameters = jsonObjectSchema.parse(input);
+            const executionParameters = contract.name === "extract_artifact"
+                ? {
+                    ...parameters,
+                    output_root: createArtifactExtractionDestination(),
+                }
+                : parameters;
             if (options.permissionAuthority !== undefined) {
-                const request = permissionRequest(contract.name, parameters);
+                const request = permissionRequest(contract.name, executionParameters);
                 if (request !== undefined) {
                     const authorized = await options.permissionAuthority.authorize(request, contract.name === "extract_artifact" ? "write" : "read");
                     if (!authorized.ok)
-                        return toCallToolResult(err(authorized.error instanceof PermissionRequiredError
-                            ? authorized.error
-                            : new AnalysisProtocolError(authorized.error.message, {
-                                cause: authorized.error,
-                            })), contract);
+                        return toCallToolResult(err(projectPermissionFailure(authorized.error)), contract);
                 }
             }
-            const execution = await logToolExecution(options.logger, contract.name, () => analysis.execute(contract.name, parameters, {
+            const execution = await logToolExecution(options.logger, contract.name, () => analysis.execute(contract.name, executionParameters, {
                 signal: context.mcpReq.signal,
                 progress,
             }));
@@ -61,25 +64,15 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
             const recorded = options.recordEvidence?.(evidence);
             return recorded !== undefined && !recorded.ok
                 ? toCallToolResult(recorded, contract)
-                : toCallToolResult({ ok: true, value: evidence }, contract, {
-                    evidenceResourcesAvailable: recorded !== undefined,
-                });
+                : toCallToolResult({ ok: true, value: evidence }, contract);
         });
     }
 };
 const permissionRequest = (operation, parameters) => {
     if (operation === "extract_artifact" &&
         typeof parameters.output_root === "string")
-        return {
-            capability: "artifact_extract",
-            roots: [parameters.output_root],
-            executables: [],
-            environment_names: [],
-            network: "none",
-            mount: false,
-            operation_identity: `extract_artifact:${parameters.output_root}`,
-        };
-    if (["inventory_artifact", "inspect_artifact"].includes(operation) &&
+        return artifactExtractionPermissionRequest();
+    if (operation === "inspect_artifact" &&
         parameters.native_mount_approved === true)
         return {
             capability: "native_mount",

package/dist/server/registerFunctionComparisonTool.js

@@ -1,40 +1,47 @@
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence, parseEvidence, } from "../domain/evidence.js";
+import { EvidenceIntegrityError } from "../domain/errors.js";
+import { err } from "../domain/result.js";
 import { compareFunctions } from "../domain/functionComparison.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
+import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
 import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register explicit Evidence-backed function comparison. */
 export const registerFunctionComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const expected = {
-            operation: "analyze_function",
-            predicate: "rea.analysis/v2",
-        };
-        const left = resolveSessionEvidenceIds(session, input.left_evidence_ids, expected);
-        if (!left.ok)
-            return toCallToolResult(left, contract);
-        const right = resolveSessionEvidenceIds(session, input.right_evidence_ids, expected);
-        if (!right.ok)
-            return toCallToolResult(right, contract);
-        const leftIds = left.value.map(({ evidence_id: id }) => id);
-        const rightIds = right.value.map(({ evidence_id: id }) => id);
-        const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(left.value, right.value, input.offset, input.limit));
+        let leftEvidence;
+        let rightEvidence;
+        try {
+            leftEvidence = parseEvidence(input.left);
+            rightEvidence = parseEvidence(input.right);
+        }
+        catch (cause) {
+            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
+        }
+        if (leftEvidence.operation !== "analyze_function" ||
+            rightEvidence.operation !== "analyze_function" ||
+            leftEvidence.predicate_type !== "rea.analysis" ||
+            rightEvidence.predicate_type !== "rea.analysis")
+            return toCallToolResult(err(new EvidenceIntegrityError("Expected analyze_function Evidence")), contract);
+        const leftIds = [leftEvidence.evidence_id];
+        const rightIds = [rightEvidence.evidence_id];
+        const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(leftEvidence, rightEvidence));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
+        const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftEvidence, rightEvidence]);
+        if (!recordedSources.ok)
+            return toCallToolResult(recordedSources, contract);
         const evidence = createEvidence(undefined, FUNCTION_COMPARISON_PROVIDER, {
-            predicateType: "rea.function-comparison/v1",
+            predicateType: "rea.function-comparison",
             operation: contract.name,
             parameters: {
-                left_evidence_ids: leftIds,
-                right_evidence_ids: rightIds,
-                offset: input.offset,
-                limit: input.limit,
+                left_evidence_id: leftEvidence.evidence_id,
+                right_evidence_id: rightEvidence.evidence_id,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -43,7 +50,6 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             evidenceLinks: [...leftIds, ...rightIds],
         });
         const recorded = recordDerivedEvidence(session, evidence, functionUnknownInput({
-            approved: input.unknown_registry_approved,
             status: comparison.status,
             leftIds,
             rightIds,
@@ -51,11 +57,10 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
         return toCallToolResult(recorded, contract);
     });
 };
-const functionUnknownInput = ({ approved, status, leftIds, rightIds, }) => {
-    if (approved !== true || status === "unchanged")
+const functionUnknownInput = ({ status, leftIds, rightIds, }) => {
+    if (status === "unchanged")
         return undefined;
     return {
-        approved: true,
         question: `Function comparison is ${status}`,
         severity: status === "changed" ? "medium" : "high",
         domain: "function-comparison",
@@ -67,7 +72,7 @@ const functionUnknownInput = ({ approved, status, leftIds, rightIds, }) => {
         recommended_probes: [
             {
                 operation: "analyze_function",
-                rationale: "Capture complete dossiers for both functions under the same target context and analysis limits.",
+                rationale: "Capture complete dossiers for both functions under the same target context.",
             },
         ],
         relationships: [],

package/dist/server/registerInvestigationTools/helpers.js

@@ -1,22 +1,12 @@
 import { EvidenceIntegrityError, } from "../../domain/errors.js";
 import { err, ok } from "../../domain/result.js";
 import { recordDerivedEvidence } from "../recordDerivedEvidence.js";
-import { evaluateReconstructionClosure } from "../../domain/reconstructionCoverage.js";
-import { AnalysisInputError } from "../../domain/errors.js";
-/** Build the execution context passed to cross-version investigation. */
-export const investigationContext = ({ session, signal, inputRoots, integrityContinueEnabled, progress, }) => ({
-    session,
-    signal,
-    inputRoots,
-    integrityContinueEnabled,
-    ...(progress === undefined ? {} : { progress }),
-});
 export const isIncomplete = (status) => status === "unknown" || status === "truncated";
 export const comparisonClosure = (comparisons) => uniqueIds(comparisons.flatMap((evidence) => [
     evidence.evidence_id,
     ...evidence.evidence_links,
 ]));
-export const functionEvidenceIds = (groups) => uniqueIds(groups.flatMap((group) => (Array.isArray(group) ? group : [group]).map(({ evidence_id: id }) => id)));
+export const functionEvidenceIds = (records) => uniqueIds(records.map(({ evidence_id }) => evidence_id));
 const uniqueIds = (ids) => [...new Set(ids)].sort((left, right) => left.localeCompare(right));
 export const evidenceClosure = (session, seedIds) => {
     const records = new Map(session
@@ -36,30 +26,11 @@ export const evidenceClosure = (session, seedIds) => {
     }
     return ok(uniqueIds([...visited]));
 };
-/** Verify a retained coverage boundary before reconstruction evidence is derived. */
-export const verifyCoverageReadiness = (session, coverage) => {
-    if (coverage === undefined)
-        return ok(null);
-    const workspace = session.reconstructionCoverageWorkspace(coverage.workspace_id, coverage.revision);
-    if (workspace === undefined ||
-        workspace.revision_sha256 !== coverage.revision_sha256)
-        return err(new EvidenceIntegrityError("The requested reconstruction coverage revision is not retained by this session"));
-    try {
-        const result = evaluateReconstructionClosure(workspace, coverage.boundary_id, Date.now());
-        return result.status === "ready"
-            ? ok(null)
-            : err(new EvidenceIntegrityError(`Reconstruction coverage boundary is ${result.status}; readiness requires ready`));
-    }
-    catch (cause) {
-        return err(new AnalysisInputError("verify_reconstruction", { cause }));
-    }
-};
-export const recordWorkflowEvidence = (...[session, evidence, approved, unresolved, input]) => {
-    if (approved !== true || !unresolved) {
+export const recordWorkflowEvidence = (...[session, evidence, unresolved, input]) => {
+    if (!unresolved) {
         return recordDerivedEvidence(session, evidence, undefined);
     }
     return recordDerivedEvidence(session, evidence, {
-        approved: true,
         question: input.question,
         severity: "high",
         domain: input.domain,

package/dist/server/registerInvestigationTools.js

@@ -1,54 +1,37 @@
-import { runCrossVersionInvestigationValidated } from "../application/CrossVersionInvestigation.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../application/DeferredFileAuthorization.js";
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { buildCallPath } from "../domain/callPath.js";
-import { changedBehaviorInputSchema, changedBehaviorResultSchema, findChangedBehavior, } from "../domain/changedBehavior.js";
-import {} from "../domain/errors.js";
+import { findChangedBehavior } from "../domain/changedBehavior.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { verifyReconstruction } from "../domain/reconstructionVerification.js";
 import { correlateStaticAndRuntime } from "../domain/staticRuntimeCorrelation.js";
-import { mcpProgressReporter } from "./mcpProgress.js";
-import { comparisonClosure, evidenceClosure, functionEvidenceIds, investigationContext, isIncomplete, recordWorkflowEvidence, verifyCoverageReadiness, } from "./registerInvestigationTools/helpers.js";
-import { runDerivedOperation, } from "./runDerivedOperation.js";
+import { comparisonClosure, evidenceClosure, functionEvidenceIds, isIncomplete, recordWorkflowEvidence, } from "./registerInvestigationTools/helpers.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-composed differential investigation workflows. */
-export const registerInvestigationTools = (server, session, contracts, policies) => {
-    registerChangedBehavior(server, session, contracts[0], policies);
+export const registerInvestigationTools = (server, session, contracts) => {
+    registerChangedBehavior(server, session, contracts[0]);
     registerCallPath(server, session, contracts[1]);
     registerStaticRuntime(server, session, contracts[2]);
     registerReconstruction(server, session, contracts[3]);
 };
-const registerChangedBehavior = (server, session, contract, policies) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const investigationRun = input.investigation_run;
-        if (investigationRun !== undefined)
-            return runAutomaticInvestigation({
-                server,
-                session,
-                contract,
-                policies,
-                investigationRun,
-                unknownRegistryApproved: input.unknown_registry_approved,
-                context,
-            });
+const registerChangedBehavior = (server, session, contract) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, comparisonClosure(input.comparisons));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons, input.offset, input.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
-            predicateType: "rea.changed-behavior/v1",
+            predicateType: "rea.changed-behavior",
             operation: contract.name,
             parameters: {
                 comparison_evidence_ids: input.comparisons.map(({ evidence_id: id }) => id),
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -56,7 +39,7 @@ const registerChangedBehavior = (server, session, contract, policies) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, isIncomplete(result.behavior_status), {
+        const recorded = recordWorkflowEvidence(session, evidence, isIncomplete(result.behavior_status), {
             question: "Did both versions behave the same under a complete controlled replay?",
             domain: "changed-behavior",
             requiredAuthority: "controlled-replay",
@@ -71,75 +54,8 @@ const registerChangedBehavior = (server, session, contract, policies) => {
         return toCallToolResult(recorded, contract);
     });
 };
-const runAutomaticInvestigation = async (input) => {
-    const { policies, investigationRun, contract, session } = input;
-    const progress = mcpProgressReporter(input.context);
-    let workspaceAuthorization;
-    let authorizeInputRead;
-    if (policies.permissionAuthority !== undefined) {
-        const authority = policies.permissionAuthority;
-        const authorizedWorkspace = await authorizeFileReadWithDeferredWrite(authority, {
-            path: investigationRun.workspace_path,
-            readCapability: "investigation_workspace_read",
-            writeCapability: "investigation_workspace_write",
-            operation: contract.name,
-        });
-        if (!authorizedWorkspace.ok)
-            return toCallToolResult(authorizedWorkspace, contract);
-        workspaceAuthorization = authorizedWorkspace.value;
-        authorizeInputRead = () => authorizeRootPermission(authority, {
-            capability: "investigation_input",
-            roots: [investigationRun.left_path, investigationRun.right_path],
-            access: "read",
-            operation: contract.name,
-        });
-    }
-    const investigated = await runCrossVersionInvestigationValidated(investigationRun, policies.evidenceFiles, {
-        ...investigationContext({
-            session,
-            signal: input.context.mcpReq.signal,
-            inputRoots: policies.inputRoots,
-            integrityContinueEnabled: policies.integrityContinueEnabled?.() ?? false,
-            progress,
-        }),
-        ...(workspaceAuthorization === undefined
-            ? {}
-            : { authorizeWorkspaceWrite: workspaceAuthorization.authorizeWrite }),
-        ...(authorizeInputRead === undefined ? {} : { authorizeInputRead }),
-    });
-    if (!investigated.ok)
-        return toCallToolResult(investigated, contract);
-    const workspace = investigated.value.workspace;
-    session.retainInvestigationWorkspace(workspace);
-    const result = changedBehaviorResultSchema.parse(investigated.value.evidence.normalized_result);
-    const toolResult = toCallToolResult(recordWorkflowEvidence(session, investigated.value.evidence, input.unknownRegistryApproved, isIncomplete(result.behavior_status), {
-        question: `Automatic changed behavior run ${result.investigation_run?.run_id ?? "unknown"} remains ${result.behavior_status}`,
-        domain: "changed-behavior",
-        requiredAuthority: "controlled-replay",
-        requiredConfidence: "observed",
-        probes: [
-            {
-                operation: "capture_process_scenario",
-                rationale: "Capture both versions under the same bounded scenario and environment.",
-            },
-        ],
-    }), contract);
-    return {
-        ...toolResult,
-        content: [
-            ...toolResult.content,
-            {
-                type: "resource_link",
-                uri: `rea://workspace/${workspace.workspace_id}/revision/${String(workspace.revision)}`,
-                name: `${workspace.workspace_id} revision ${String(workspace.revision)}`,
-                description: "Immutable CAS-linked investigation workspace revision",
-                mimeType: "application/json",
-            },
-        ],
-    };
-};
 const registerCallPath = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, functionEvidenceIds(input.functions));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
@@ -149,15 +65,11 @@ const registerCallPath = (server, session, contract) => {
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {
-            predicateType: "rea.call-path/v1",
+            predicateType: "rea.call-path",
             operation: contract.name,
             parameters: {
                 start: input.start.address,
                 goal: input.goal.address,
-                max_depth: input.max_depth,
-                max_paths: input.max_paths,
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -165,7 +77,7 @@ const registerCallPath = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        const recorded = recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Can the requested call path be established from complete analysis?",
             domain: "call-path",
             requiredAuthority: "shipped-artifact",
@@ -181,7 +93,7 @@ const registerCallPath = (server, session, contract) => {
     });
 };
 const registerStaticRuntime = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, comparisonClosure([
             ...input.static_comparisons,
             ...input.runtime_comparisons,
@@ -194,12 +106,10 @@ const registerStaticRuntime = (server, session, contract) => {
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {
-            predicateType: "rea.static-runtime-correlation/v1",
+            predicateType: "rea.static-runtime-correlation",
             operation: contract.name,
             parameters: {
                 mapping_count: input.mappings.length,
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "inferred",
@@ -207,7 +117,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
             question: "Does runtime behavior match the available static analysis?",
             domain: "static-runtime-correlation",
             requiredAuthority: null,
@@ -222,12 +132,9 @@ const registerStaticRuntime = (server, session, contract) => {
     });
 };
 const registerReconstruction = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const coverage = verifyCoverageReadiness(session, input.coverage);
-        if (!coverage.ok)
-            return toCallToolResult(coverage, contract);
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const owned = session.exportEvidenceBundle();
-        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned, input.offset, input.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -236,13 +143,11 @@ const registerReconstruction = (server, session, contract) => {
             return toCallToolResult(closure, contract);
         const links = closure.value;
         const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {
-            predicateType: "rea.reconstruction-verification/v1",
+            predicateType: "rea.reconstruction-verification",
             operation: contract.name,
             parameters: {
                 specification_sha256: result.specification_sha256,
                 claim_ids: input.specification.claims.map(({ claim_id: id }) => id),
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -250,7 +155,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,
@@ -262,4 +167,3 @@ const registerReconstruction = (server, session, contract) => {
         }), contract);
     });
 };
-const contractOptions = toolRegistrationOptions;

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -1,5 +1,6 @@
 import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/JavaScriptRuntimeObservationService.js";
 import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "../contracts/javascriptRuntimeObservationToolContracts.js";
+import { observeJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
@@ -7,7 +8,10 @@ import { toCallToolResult } from "./toolResult.js";
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
     const [listContract, observeContract] = JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS;
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal })));
-    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, (parsed, signal) => observeJavaScriptRuntime(options.runtime, options.permissionAuthority, parsed, { signal })));
+    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, async (parsed, signal) => {
+        const request = observeJavaScriptRuntimeInputSchema.parse(parsed);
+        return observeJavaScriptRuntime(options.runtime, options.permissionAuthority, request, { signal });
+    }));
 };
 const runRuntimeTool = async (options, contract, request, execute) => {
     const { input, context } = request;
@@ -17,7 +21,5 @@ const runRuntimeTool = async (options, contract, request, execute) => {
     const recorded = options.recordEvidence?.(result.value);
     return recorded !== undefined && !recorded.ok
         ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: result.value }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        : toCallToolResult({ ok: true, value: result.value }, contract);
 };