rea-agents 3.1.0 → 3.2.1

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,19 +1,16 @@
-import { resolveCompareApplicationVersionsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { recordResult } from "./helpers.js";
 const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
 export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const resolved = resolveCompareApplicationVersionsRequestValidated(input, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, compareContract);
-        const parsed = resolved.value;
+        const parsed = input;
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, compareContract);
@@ -23,13 +20,11 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
             ...parsed.left_native_observations,
             ...parsed.right_native_observations,
         ];
-        const recorded = recordSources(options.recordEvidence, sources);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
             return toCallToolResult(recorded, compareContract);
         const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, compareContract, result.value, parsed.unknown_registry_approved === true && unknown
-            ? "application-version-comparison"
-            : undefined);
+        return recordResult(options, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
     });
 };

package/dist/server/registerApplicationTools/controlledReplay.js

@@ -1,3 +1,4 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { parseEvidence } from "../../domain/evidence.js";
@@ -6,7 +7,6 @@ import { mcpProgressReporter } from "../mcpProgress.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordSources } from "./helpers.js";
 const replayContract = applicationToolContract("run_controlled_replay");
 /** Register the controlled JavaScript replay tool. */
 export const registerControlledReplayTool = (server, options) => {
@@ -19,15 +19,13 @@ export const registerControlledReplayTool = (server, options) => {
             return toCallToolResult(result, replayContract);
         const output = controlledReplayOutputSchema.parse(result.value);
         if (output.phase === "execute") {
-            const sourcesRecorded = recordSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
+            const sourcesRecorded = recordSessionEvidenceSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
             if (!sourcesRecorded.ok)
                 return toCallToolResult(sourcesRecorded, replayContract);
             const recorded = options.recordEvidence?.(parseEvidence(output.evidence));
             if (recorded !== undefined && !recorded.ok)
                 return toCallToolResult(recorded, replayContract);
         }
-        return toCallToolResult(result, replayContract, {
-            evidenceResourcesAvailable: output.phase === "execute" && options.recordEvidence !== undefined,
-        });
+        return toCallToolResult(result, replayContract);
     });
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -1,78 +1,13 @@
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../../application/DeferredFileAuthorization.js";
-import { commitReconstructionCoverage, queryReconstructionCoverage, } from "../../application/ReconstructionCoverageService.js";
-import { readReconstructionCoverageWorkspace } from "../../application/ReconstructionCoverageWorkspaceStore.js";
+import { evaluateReconstructionCoverage } from "../../application/ReconstructionCoverageService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, } from "../../domain/errors.js";
-import { reconstructionClosureResultSchema } from "../../domain/reconstructionCoverage.js";
-import { err } from "../../domain/result.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { coverageWorkspaceUri } from "./helpers.js";
-const commitContract = applicationToolContract("commit_reconstruction_coverage");
-const queryContract = applicationToolContract("query_reconstruction_coverage");
-/** Register reconstruction coverage commit and query tools. */
+const contract = applicationToolContract("evaluate_reconstruction_coverage");
+/** Register the inline fail-closed reconstruction coverage evaluator. */
 export const registerCoverageTools = (server, options) => {
-    registerCommitTool(server, options);
-    registerQueryTool(server, options);
-};
-const registerCommitTool = (server, options) => {
-    server.registerTool(commitContract.name, toolRegistrationOptions(commitContract), async (input, context) => {
-        if (options.permissionAuthority === undefined)
-            return toCallToolResult(err(new AnalysisCapabilityUnavailableError("rea-reconstruction-coverage", commitContract.name, "workspace permission policy is not configured")), commitContract);
-        const authorization = await authorizeFileReadWithDeferredWrite(options.permissionAuthority, {
-            path: input.workspace_path,
-            readCapability: "investigation_workspace_read",
-            writeCapability: "investigation_workspace_write",
-            operation: commitContract.name,
-        });
-        if (!authorization.ok)
-            return toCallToolResult(authorization, commitContract);
-        const write = await authorization.value.authorizeWrite();
-        if (!write.ok)
-            return toCallToolResult(write, commitContract);
-        const result = await logToolExecution(options.logger, commitContract.name, () => commitReconstructionCoverage(input, options.evidenceFilePolicy, {
-            signal: context.mcpReq.signal,
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, commitContract);
-        options.retainCoverageWorkspace?.(input.workspace);
-        return toCallToolResult(result, commitContract, {
-            resourceLinks: options.retainCoverageWorkspace === undefined
-                ? []
-                : [
-                    {
-                        uri: coverageWorkspaceUri(input.workspace),
-                        name: input.workspace.workspace_id,
-                        description: "Session-retained reconstruction coverage workspace revision",
-                    },
-                ],
-        });
-    });
-};
-const registerQueryTool = (server, options) => {
-    server.registerTool(queryContract.name, toolRegistrationOptions(queryContract), async (input, context) => {
-        if (options.permissionAuthority === undefined)
-            return toCallToolResult(err(new AnalysisCapabilityUnavailableError("rea-reconstruction-coverage", queryContract.name, "workspace permission policy is not configured")), queryContract);
-        const authorized = await authorizeRootPermission(options.permissionAuthority, {
-            capability: "investigation_workspace_read",
-            roots: [input.workspace_path],
-            access: "read",
-            operation: queryContract.name,
-        });
-        if (!authorized.ok)
-            return toCallToolResult(authorized, queryContract);
-        const result = await logToolExecution(options.logger, queryContract.name, () => queryReconstructionCoverage(input, options.evidenceFilePolicy, Date.now(), { signal: context.mcpReq.signal }));
-        if (result.ok && options.retainCoverageWorkspace !== undefined) {
-            const closure = reconstructionClosureResultSchema.parse(result.value);
-            const loaded = await readReconstructionCoverageWorkspace(input.workspace_path, options.evidenceFilePolicy);
-            if (!loaded.ok)
-                return toCallToolResult(loaded, queryContract);
-            if (loaded.value === null ||
-                loaded.value.revision_sha256 !== closure.workspace_revision_sha256)
-                return toCallToolResult(err(new EvidenceIntegrityError("workspace changed while its closure was being retained")), queryContract);
-            options.retainCoverageWorkspace(loaded.value);
-        }
-        return toCallToolResult(result, queryContract);
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionCoverage(input)));
+        return toCallToolResult(result, contract);
     });
 };

package/dist/server/registerApplicationTools/helpers.js

@@ -1,26 +1,14 @@
 import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
 import { toCallToolResult } from "../toolResult.js";
-export const coverageWorkspaceUri = (workspace) => `rea://reconstruction-coverage/${workspace.workspace_id}/revision/${String(workspace.revision)}`;
-export const recordSources = (recordEvidence, sources) => {
-    for (const source of sources) {
-        const recorded = recordEvidence?.(source);
-        if (recorded !== undefined && !recorded.ok)
-            return recorded;
-    }
-    return { ok: true, value: null };
-};
 export const recordResult = (options, contract, evidence, unknownKind) => {
     const recorded = unknownKind === undefined
         ? options.recordEvidence?.(evidence)
         : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
     if (recorded !== undefined && !recorded.ok)
         return toCallToolResult(recorded, contract);
-    return toCallToolResult({ ok: true, value: evidence }, contract, {
-        evidenceResourcesAvailable: recorded !== undefined,
-    });
+    return toCallToolResult({ ok: true, value: evidence }, contract);
 };
 const unknownRegistration = (evidence, kind) => ({
-    approved: true,
     question: kind === "application-version-comparison"
         ? "Which application entities remain unmatched or ambiguous across these versions?"
         : kind === "source-to-bundle-comparison"

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -1,9 +1,10 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstructionObligationLedgerRequest, } from "../../application/ReconstructionObligationLedgerService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("build_reconstruction_obligation_ledger");
 /** Register conservative reconstruction-obligation generation and closure. */
 export const registerReconstructionObligationLedgerTool = (server, options) => {
@@ -14,7 +15,7 @@ export const registerReconstructionObligationLedgerTool = (server, options) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(buildReconstructionObligationLedgerEvidenceValidated(resolved.value)));
         if (!result.ok)
             return toCallToolResult(result, contract);
-        const recorded = recordSources(options.recordEvidence, resolved.value.evidence_bundle.records);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, resolved.value.evidence_bundle.records);
         if (!recorded.ok)
             return toCallToolResult(recorded, contract);
         return recordResult(options, contract, result.value);

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,23 +1,19 @@
-import { resolveTraceApplicationFeatureRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { recordResult } from "./helpers.js";
 const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
 export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
-        const resolved = resolveTraceApplicationFeatureRequestValidated(input, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, traceContract);
-        const parsed = resolved.value;
-        const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
+        const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(input)));
         if (!result.ok)
             return toCallToolResult(result, traceContract);
-        const sources = [parsed.application, ...parsed.native_observations];
-        const recorded = recordSources(options.recordEvidence, sources);
+        const sources = [input.application, ...input.native_observations];
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
             return toCallToolResult(recorded, traceContract);
         return recordResult(options, traceContract, result.value);

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,22 +1,19 @@
-import { resolveTraceJavaScriptSemanticsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/JavaScriptSemanticTraceService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
 export const registerTraceJavaScriptSemanticsTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const resolved = resolveTraceJavaScriptSemanticsRequestValidated(input, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(resolved.value)));
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(input)));
         if (!result.ok)
             return toCallToolResult(result, contract);
-        const recorded = recordSources(options.recordEvidence, [
-            resolved.value.application,
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
+            input.application,
         ]);
         if (!recorded.ok)
             return toCallToolResult(recorded, contract);

package/dist/server/registerApplicationTools.js

@@ -7,7 +7,6 @@ import { registerControlledReplayTool } from "./registerApplicationTools/control
 import { registerCharacterizationTools } from "./registerApplicationTools/characterization.js";
 import { registerCoverageTools } from "./registerApplicationTools/coverage.js";
 import { registerReconstructionObligationLedgerTool } from "./registerApplicationTools/obligationLedger.js";
-import { registerReconstructionReadinessTool } from "./registerApplicationTools/readiness.js";
 /** Register provider-neutral JavaScript application graph workflows. */
 export const registerApplicationTools = (server, options) => {
     registerTraceFeatureTool(server, options);
@@ -18,6 +17,5 @@ export const registerApplicationTools = (server, options) => {
     registerControlledReplayTool(server, options);
     registerCharacterizationTools(server, options);
     registerReconstructionObligationLedgerTool(server, options);
-    registerReconstructionReadinessTool(server, options);
     registerCoverageTools(server, options);
 };

package/dist/server/registerArtifactComparisonTool.js

@@ -1,40 +1,37 @@
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { compareArtifacts } from "../domain/artifactComparison.js";
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
 import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const expected = {
-            operation: "inventory_artifact",
-            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 computed = await runDerivedOperation(context, contract.name, () => compareArtifacts(left.value, right.value, input.offset, input.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => {
+            const left = parseEvidence(input.left);
+            const right = parseEvidence(input.right);
+            return { left, right, comparison: compareArtifacts(left, right) };
+        });
         if (!computed.ok)
             return toCallToolResult(computed, contract);
-        const comparison = computed.value;
-        const leftEvidenceIds = input.left_evidence_ids;
-        const rightEvidenceIds = input.right_evidence_ids;
+        const { left, right, comparison } = computed.value;
+        const sources = [left, right];
+        for (const source of sources) {
+            const recordedSource = session.recordEvidence(source);
+            if (!recordedSource.ok)
+                return toCallToolResult(recordedSource, contract);
+        }
+        const leftEvidenceIds = [left.evidence_id];
+        const rightEvidenceIds = [right.evidence_id];
         const evidence = createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
-            predicateType: "rea.artifact-comparison/v1",
+            predicateType: "rea.artifact-comparison",
             operation: contract.name,
             parameters: {
                 left_evidence_ids: leftEvidenceIds,
                 right_evidence_ids: rightEvidenceIds,
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -42,26 +39,25 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(input, comparison.status)), contract);
+        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status)), contract);
     });
 };
-const artifactUnknownInput = (input, status) => {
-    if (input.unknown_registry_approved !== true || status === "unchanged")
+const artifactUnknownInput = (left, right, status) => {
+    if (status === "unchanged" || left.evidence_id === right.evidence_id)
         return undefined;
     return {
-        approved: true,
         question: `Artifact comparison is ${status}`,
         severity: status === "unknown" || status === "truncated" ? "high" : "medium",
         domain: "artifact-comparison",
-        supporting_evidence_ids: [...input.left_evidence_ids],
-        contradicting_evidence_ids: [...input.right_evidence_ids],
+        supporting_evidence_ids: [left.evidence_id],
+        contradicting_evidence_ids: [right.evidence_id],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,
         recommended_probes: [
             {
-                operation: "inventory_artifact",
-                rationale: "Capture both complete artifact graphs under equal limits.",
+                operation: "inspect_artifact",
+                rationale: "Inspect both artifacts and compare their complete graphs.",
             },
         ],
         relationships: [],

package/dist/server/registerBrowserScenarioTool.js

@@ -1,5 +1,6 @@
 import { captureBrowserScenario } from "../application/BrowserScenarioCaptureService.js";
 import { BROWSER_SCENARIO_TOOL_CONTRACTS } from "../contracts/browserScenarioToolContracts.js";
+import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
@@ -7,14 +8,13 @@ import { toCallToolResult } from "./toolResult.js";
 export const registerBrowserScenarioTool = (server, options) => {
     const [contract] = BROWSER_SCENARIO_TOOL_CONTRACTS;
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, options.permissionAuthority, input, { signal: context.mcpReq.signal }));
+        const scenario = browserScenarioSchema.parse(input);
+        const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, options.permissionAuthority, scenario, { signal: context.mcpReq.signal }));
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);
         return recorded !== undefined && !recorded.ok
             ? toCallToolResult(recorded, contract)
-            : toCallToolResult({ ok: true, value: result.value }, contract, {
-                evidenceResourcesAvailable: recorded !== undefined,
-            });
+            : toCallToolResult({ ok: true, value: result.value }, contract);
     });
 };

package/dist/server/registerBrowserTools.js

@@ -1,5 +1,7 @@
 import { analyzeWebBundle, captureWebScreenshot, compareWebCaptureEvidence, compareWebScreenshotEvidence, discoverWebMcpTools, inspectWebPage, listBrowserTargets, observeWebSession, } from "../application/BrowserObservationService.js";
 import { BROWSER_TOOL_CONTRACTS } from "../contracts/browserToolContracts.js";
+import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
+import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -11,11 +13,8 @@ export const registerBrowserTools = (server, options) => {
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(options, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, options.permissionAuthority, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, options.permissionAuthority, parsed, {
-        signal,
-        progress,
-    })));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, parsed, {
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, options.permissionAuthority, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, analyzeWebBundleInputSchema.parse(parsed), {
         signal,
         progress,
     })));
@@ -48,7 +47,5 @@ const evidenceResult = (options, contract, evidence) => {
     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);
 };

package/dist/server/registerBundleComparisonTool.js

@@ -9,29 +9,27 @@ import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register canonical Evidence bundle comparison. */
-export const registerBundleComparisonTool = (server, session, contract, evidenceFilePolicy) => {
+export const registerBundleComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const [left, right] = await Promise.all([
-            readEvidenceBundle(input.left_bundle_path, evidenceFilePolicy),
-            readEvidenceBundle(input.right_bundle_path, evidenceFilePolicy),
+            readEvidenceBundle(input.left_bundle_path),
+            readEvidenceBundle(input.right_bundle_path),
         ]);
         if (!left.ok)
             return toCallToolResult(left, contract);
         if (!right.ok)
             return toCallToolResult(right, contract);
-        const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, input.record_pairs, input.offset, input.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, input.record_pairs));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
         const evidence = createEvidence(undefined, BUNDLE_COMPARISON_PROVIDER, {
-            predicateType: "rea.bundle-comparison/v1",
+            predicateType: "rea.bundle-comparison",
             operation: contract.name,
             parameters: {
                 left_bundle_sha256: comparison.left_bundle_sha256,
                 right_bundle_sha256: comparison.right_bundle_sha256,
                 record_pairs: input.record_pairs,
-                offset: input.offset,
-                limit: input.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",

package/dist/server/registerCloseLifecycleTool.js

@@ -2,12 +2,11 @@ import { writeAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
 import { ok } from "../domain/result.js";
 import { reportLifecycleEnd, reportLifecycleStart, } from "./lifecycleProgress.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { permissionFailure } from "./permissionFailure.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register provider cleanup and optional pre-close snapshot persistence. */
-export const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], snapshotFilePolicy, permissionAuthority, }) => {
+export const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input, context) => {
         const progress = mcpProgressReporter(context);
         if (input.snapshot_path === undefined) {
@@ -16,23 +15,10 @@ export const registerCloseLifecycleTool = ({ server, session, logger, contracts:
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
             return toCallToolResult(closed, closeContract);
         }
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "snapshot_write",
-                roots: [input.snapshot_path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `close_binary:snapshot:${input.snapshot_path}`,
-            }, "write");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), closeContract);
-        }
         const snapshot = session.exportAnalysisSnapshot();
         if (!snapshot.ok)
             return toCallToolResult(snapshot, closeContract);
-        const written = await writeAnalysisSnapshot(snapshot.value, input.snapshot_path, input.overwrite, snapshotFilePolicy);
+        const written = await writeAnalysisSnapshot(snapshot.value, input.snapshot_path, input.overwrite);
         if (!written.ok)
             return toCallToolResult(written, closeContract);
         await reportLifecycleStart(progress, closeContract.name, "snapshot written; closing provider");

package/dist/server/registerElectronTools.js

@@ -3,7 +3,7 @@ import { inspectElectronPage, listElectronTargets, } from "../application/Electr
 import { analyzeJavaScriptApplicationValidated } from "../application/JavaScriptApplicationService.js";
 import { reconcileJavaScriptRuntimeEvidenceValidated } from "../application/JavaScriptRuntimeReconciliationService.js";
 import { ELECTRON_TOOL_CONTRACTS } from "../contracts/electronToolContracts.js";
-import { summarizeJavaScriptApplicationEvidence } from "./javascriptApplicationResult.js";
+import { inspectElectronPageInputSchema } from "../domain/electronObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -15,46 +15,27 @@ export const registerElectronTools = (server, options) => {
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(options, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, options.permissionAuthority, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectElectronPage(options.electron, options.permissionAuthority, parsed, {
-        signal,
-        progress,
-    })));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, {
-        input,
-        context,
-        projectEvidence: (evidence, parsed) => {
-            const summary = summarizeJavaScriptApplicationEvidence(evidence);
-            return parsed.detail === "full"
-                ? { structured: evidence.normalized_result, text: summary }
-                : { structured: summary };
-        },
-    }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(options.permissionAuthority, parsed, { signal, progress })));
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(options, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
+        const request = inspectElectronPageInputSchema.parse(parsed);
+        return inspectElectronPage(options.electron, options.permissionAuthority, request, { signal, progress });
+    }));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
     server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(options, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
     server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(options, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, options.permissionAuthority, parsed, { signal, progress })));
 };
 const runElectronTool = async (options, contract, request, execute) => {
-    const { input, context, projectEvidence } = request;
+    const { input, context } = request;
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),
     }));
     if (!result.ok)
         return toCallToolResult(result, contract);
-    return evidenceResult(options, contract, result.value, projectEvidence?.(result.value, input));
+    return evidenceResult(options, contract, result.value);
 };
-const evidenceResult = (options, contract, evidence, projection) => {
+const evidenceResult = (options, contract, evidence) => {
     const recorded = options.recordEvidence?.(evidence);
     return recorded !== undefined && !recorded.ok
         ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-            ...(projection === undefined
-                ? {}
-                : {
-                    evidenceResultProjection: projection.structured,
-                    ...(projection.text === undefined
-                        ? {}
-                        : { evidenceTextProjection: projection.text }),
-                }),
-        });
+        : toCallToolResult({ ok: true, value: evidence }, contract);
 };