rea-agents 3.0.0 → 3.2.0

package/dist/server/promptCompletion.js

@@ -1,10 +1,7 @@
 import { z } from "zod";
 import { artifactInventoryResultSchema } from "../domain/artifactGraph.js";
-import { parseAddressedPage } from "../domain/hopperValues.js";
-import { processCaptureSchema, validateProcessCapture, } from "../domain/processCapture.js";
-const COMPLETION_SCAN_LIMIT = 10_000;
-const PROCEDURE_PAGE_SIZE = 500;
-const MAX_COMPLETION_VALUE_LENGTH = 4_096;
+import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
+import { processCaptureSchema } from "../domain/processCapture.js";
 const documentListSchema = z.array(z.string().min(1));
 const providerStatusSchema = z.object({
     providers: z.array(z.object({ id: z.string().min(1) })),
@@ -12,16 +9,12 @@ const providerStatusSchema = z.object({
         .array(z.object({ provider: z.object({ id: z.string().min(1) }) }))
         .optional(),
 });
-/** Build bounded live completion over the active provider and session ledger. */
+/** Build live completion over the active provider and session ledger. */
 export const createPromptCompletionSource = (analysis, session) => ({
     async complete(kind, value, context) {
-        if (value.length > MAX_COMPLETION_VALUE_LENGTH)
-            return [];
         const candidates = await completionCandidates(kind, analysis, session, context);
         const prefix = normalize(value);
-        return uniqueSorted(candidates)
-            .filter((candidate) => normalize(candidate).startsWith(prefix))
-            .slice(0, COMPLETION_SCAN_LIMIT);
+        return uniqueSorted(candidates).filter((candidate) => normalize(candidate).startsWith(prefix));
     },
 });
 const completionCandidates = async (kind, analysis, session, context) => {
@@ -46,39 +39,20 @@ const documentCandidates = async (analysis) => {
     if (!result.ok)
         return [];
     const parsed = documentListSchema.safeParse(result.value.result);
-    return parsed.success ? parsed.data.slice(0, COMPLETION_SCAN_LIMIT) : [];
+    return parsed.success ? parsed.data : [];
 };
 const procedureCandidates = async (analysis, document) => {
-    if (document !== undefined && document.length > MAX_COMPLETION_VALUE_LENGTH)
-        return [];
     const byAddress = new Map();
-    let offset = 0;
-    let exhaustive = false;
-    while (byAddress.size < COMPLETION_SCAN_LIMIT / 2) {
-        const result = await analysis.execute("list_procedures", {
-            offset,
-            limit: PROCEDURE_PAGE_SIZE,
-            ...(document === undefined || document.length === 0 ? {} : { document }),
-        });
-        if (!result.ok)
-            break;
-        const parsed = parseAddressedPage(result.value.result);
-        if (!parsed.ok)
-            break;
-        for (const item of parsed.value.items) {
-            if (byAddress.size >= COMPLETION_SCAN_LIMIT / 2)
-                break;
-            if (!byAddress.has(item.address))
-                byAddress.set(item.address, item.name);
-        }
-        const nextOffset = parsed.value.nextOffset;
-        if (!parsed.value.hasMore) {
-            exhaustive = true;
-            break;
-        }
-        if (nextOffset === null || nextOffset <= offset)
-            break;
-        offset = nextOffset;
+    const input = document === undefined || document.length === 0 ? {} : { document };
+    const result = await analysis.execute("list_procedures", input);
+    if (result.ok) {
+        const parsed = z
+            .array(z.object({ address: z.string(), value: z.string() }))
+            .safeParse(result.value.result);
+        if (parsed.success)
+            for (const item of parsed.data)
+                if (!byAddress.has(item.address))
+                    byAddress.set(item.address, item.value);
     }
     const addressesByName = new Map();
     for (const [address, name] of byAddress) {
@@ -87,10 +61,9 @@ const procedureCandidates = async (analysis, document) => {
         addressesByName.set(name, addresses);
     }
     const candidates = [...byAddress.keys()];
-    if (exhaustive)
-        for (const [name, addresses] of addressesByName)
-            if (addresses.size === 1 && name.length > 0)
-                candidates.push(name);
+    for (const [name, addresses] of addressesByName)
+        if (addresses.size === 1 && name.length > 0)
+            candidates.push(name);
     return candidates;
 };
 const providerCandidates = (session) => {
@@ -102,18 +75,14 @@ const providerCandidates = (session) => {
     const candidates = (parsed.data.analysis_provider_candidates?.length ?? 0) > 0
         ? (parsed.data.analysis_provider_candidates?.map(({ provider }) => provider.id) ?? [])
         : parsed.data.providers.map(({ id }) => id);
-    return ["auto", ...candidates].slice(0, COMPLETION_SCAN_LIMIT);
+    return ["auto", ...candidates];
 };
 const evidenceCandidates = (kind, session) => {
     if (session === undefined)
         return [];
     const candidates = [];
-    for (const evidence of session.exportEvidenceBundle().records) {
-        const remaining = COMPLETION_SCAN_LIMIT - candidates.length;
-        candidates.push(...evidenceValues(kind, evidence).slice(0, remaining));
-        if (candidates.length >= COMPLETION_SCAN_LIMIT)
-            break;
-    }
+    for (const evidence of session.exportEvidenceBundle().records)
+        candidates.push(...evidenceValues(kind, evidence));
     return candidates;
 };
 const evidenceValues = (kind, evidence) => {
@@ -121,30 +90,37 @@ const evidenceValues = (kind, evidence) => {
         return [evidence.evidence_id];
     if (kind === "capture")
         return isProcessCaptureEvidence(evidence) ? [evidence.evidence_id] : [];
-    if (evidence.operation !== "inventory_artifact")
+    const inventoryResult = evidence.operation === "inventory_artifact"
+        ? evidence.normalized_result
+        : evidence.operation === "inspect_artifact"
+            ? (() => {
+                const inspection = artifactInspectionResultSchema.safeParse(evidence.normalized_result);
+                return inspection.success
+                    ? inspection.data.substeps[0]?.evidence.normalized_result
+                    : undefined;
+            })()
+            : undefined;
+    if (inventoryResult === undefined)
         return [];
-    const inventory = artifactInventoryResultSchema.safeParse(evidence.normalized_result);
+    const inventory = artifactInventoryResultSchema.safeParse(inventoryResult);
     if (!inventory.success)
         return [];
     if (kind === "manifest")
         return [inventory.data.manifest.manifest_id];
-    return inventory.data.occurrences.items.map(({ occurrence_id: id }) => id);
+    return inventory.data.occurrences.map(({ occurrence_id: id }) => id);
 };
 const isProcessCaptureEvidence = (evidence) => {
     if (evidence.operation !== "capture_process_scenario")
         return false;
     const capture = processCaptureSchema.safeParse(evidence.normalized_result);
-    return capture.success && validateProcessCapture(capture.data).length === 0;
+    return capture.success;
 };
 const unknownCandidates = (session) => session === undefined
     ? []
     : session
         .listUnknowns()
         .filter(({ status }) => status !== "resolved")
-        .map(({ unknown_id: id }) => id)
-        .slice(0, COMPLETION_SCAN_LIMIT);
-const uniqueSorted = (values) => [
-    ...new Set(values.filter((value) => value.length > 0 && value.length <= MAX_COMPLETION_VALUE_LENGTH)),
-].sort(compareText);
+        .map(({ unknown_id: id }) => id);
+const uniqueSorted = (values) => [...new Set(values.filter((value) => value.length > 0))].sort(compareText);
 const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const normalize = (value) => value.normalize("NFKC").toLowerCase();

package/dist/server/recordDerivedEvidence.js

@@ -1,5 +1,5 @@
 import { ok } from "../domain/result.js";
-/** Atomically record derived Evidence with an optional approved unknown. */
+/** Atomically record derived Evidence with an optional supported unknown. */
 export const recordDerivedEvidence = (session, evidence, unknown) => {
     if (unknown !== undefined) {
         const recorded = session.recordEvidenceWithUnknown(evidence, unknown);

package/dist/server/registerApplicationTools/characterization.js

@@ -1,22 +1,18 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
+import { mcpProgressReporter } from "../mcpProgress.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
-import { recordSources } from "./helpers.js";
+import { toCallToolResult } from "../toolResult.js";
 const prepareContract = applicationToolContract("prepare_node_characterization");
 const executeContract = applicationToolContract("execute_node_characterization");
 /** Register node runtime characterization prepare and execute tools. */
 export const registerCharacterizationTools = (server, options) => {
     server.registerTool(prepareContract.name, toolRegistrationOptions(prepareContract), async (input, context) => {
-        const parsed = safeParseToolInput(nodeCharacterizationPreparationInputSchema, input, prepareContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, prepareContract);
-        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, parsed.value, {
+        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -26,15 +22,10 @@ export const registerCharacterizationTools = (server, options) => {
         const recorded = options.recordEvidence?.(parseEvidence(output.transformation_evidence));
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, prepareContract);
-        return toCallToolResult(result, prepareContract, {
-            evidenceResourcesAvailable: options.recordEvidence !== undefined,
-        });
+        return toCallToolResult(result, prepareContract);
     });
     server.registerTool(executeContract.name, toolRegistrationOptions(executeContract), async (input, context) => {
-        const parsed = safeParseToolInput(nodeCharacterizationExecutionInputSchema, input, executeContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, executeContract);
-        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, parsed.value, {
+        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -44,14 +35,12 @@ export const registerCharacterizationTools = (server, options) => {
         const sources = [
             output.transformation_evidence,
             ...output.replay.source_evidence,
-            ...(output.replay.evidence === null ? [] : [output.replay.evidence]),
+            output.replay.evidence,
             output.evidence,
         ].map((item) => parseEvidence(item));
-        const recorded = recordSources(options.recordEvidence, sources);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
             return toCallToolResult(recorded, executeContract);
-        return toCallToolResult(result, executeContract, {
-            evidenceResourcesAvailable: options.recordEvidence !== undefined,
-        });
+        return toCallToolResult(result, executeContract);
     });
 };

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,28 +1,20 @@
-import { resolveCompareJavaScriptExportShapesRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareJavaScriptExportShapesRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { toCallToolResult } from "../toolResult.js";
+import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
 export const registerCompareJavaScriptExportShapesTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsedInput = safeParseToolInput(compareJavaScriptExportShapesRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(parsedInput.value, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
-        const parsed = resolved.value;
+        const parsed = input;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareJavaScriptExportShapesEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, contract);
-        const recorded = recordSources(options.recordEvidence, [
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
@@ -30,8 +22,6 @@ export const registerCompareJavaScriptExportShapesTool = (server, options) => {
             return toCallToolResult(recorded, contract);
         const comparison = javaScriptExportShapeComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, contract, result.value, parsed.unknown_registry_approved === true && unknown
-            ? "javascript-export-shape"
-            : undefined);
+        return recordResult(options, contract, result.value, unknown ? "javascript-export-shape" : undefined);
     });
 };

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,34 +1,25 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
-import { resolveCompareSourceToBundleRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareSourceToBundleRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { sourceToBundleComparisonResultSchema } from "../../domain/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.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("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
 export const registerCompareSourceToBundleTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsedInput = safeParseToolInput(compareSourceToBundleRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareSourceToBundleRequestValidated(parsedInput.value, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(resolved.value)));
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(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);
         const comparison = sourceToBundleComparisonResultSchema.parse(result.value.normalized_result);
-        return recordResult(options, contract, result.value, resolved.value.unknown_registry_approved === true &&
-            comparison.summary.unknown > 0
+        return recordResult(options, contract, result.value, comparison.summary.unknown > 0
             ? "source-to-bundle-comparison"
             : undefined);
     });

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,24 +1,16 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
-import { resolveCompareApplicationVersionsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareApplicationVersionsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { toCallToolResult } from "../toolResult.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 parsedInput = safeParseToolInput(compareApplicationVersionsRequestSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
-        const resolved = resolveCompareApplicationVersionsRequestValidated(parsedInput.value, 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);
@@ -28,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,38 +1,31 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../../domain/javascriptReplay.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { controlledReplayOutputSchema } from "../../domain/javascriptReplay.js";
+import { mcpProgressReporter } from "../mcpProgress.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
-import { recordSources } from "./helpers.js";
+import { toCallToolResult } from "../toolResult.js";
 const replayContract = applicationToolContract("run_controlled_replay");
 /** Register the controlled JavaScript replay tool. */
 export const registerControlledReplayTool = (server, options) => {
     server.registerTool(replayContract.name, toolRegistrationOptions(replayContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(controlledReplayInputSchema, input, replayContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, replayContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, parsed, {
+        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
             return toCallToolResult(result, replayContract);
         const output = controlledReplayOutputSchema.parse(result.value);
-        if (output.evidence !== null) {
-            const sourcesRecorded = recordSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
+        if (output.phase === "execute") {
+            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.evidence !== null && options.recordEvidence !== undefined,
-        });
+        return toCallToolResult(result, replayContract);
     });
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -1,84 +1,13 @@
-import { commitReconstructionCoverage, queryReconstructionCoverage, } from "../../application/ReconstructionCoverageService.js";
-import { readReconstructionCoverageWorkspace } from "../../application/ReconstructionCoverageWorkspaceStore.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../../application/DeferredFileAuthorization.js";
+import { evaluateReconstructionCoverage } from "../../application/ReconstructionCoverageService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionCoverageCommitInputSchema, reconstructionCoverageQueryInputSchema, } from "../../application/ReconstructionCoverageService.js";
-import { reconstructionClosureResultSchema } from "../../domain/reconstructionCoverage.js";
-import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, } from "../../domain/errors.js";
-import { err } from "../../domain/result.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.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. */
+import { toCallToolResult } from "../toolResult.js";
+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) => {
-        const parsed = safeParseToolInput(reconstructionCoverageCommitInputSchema, input, commitContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, commitContract);
-        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: parsed.value.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(parsed.value, options.evidenceFilePolicy, { signal: context.mcpReq.signal }));
-        if (!result.ok)
-            return toCallToolResult(result, commitContract);
-        options.retainCoverageWorkspace?.(parsed.value.workspace);
-        return toCallToolResult(result, commitContract, {
-            resourceLinks: options.retainCoverageWorkspace === undefined
-                ? []
-                : [
-                    {
-                        uri: coverageWorkspaceUri(parsed.value.workspace),
-                        name: parsed.value.workspace.workspace_id,
-                        description: "Session-retained reconstruction coverage workspace revision",
-                    },
-                ],
-        });
-    });
-};
-const registerQueryTool = (server, options) => {
-    server.registerTool(queryContract.name, toolRegistrationOptions(queryContract), async (input, context) => {
-        const parsed = safeParseToolInput(reconstructionCoverageQueryInputSchema, input, queryContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, queryContract);
-        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: [parsed.value.workspace_path],
-            access: "read",
-            operation: queryContract.name,
-        });
-        if (!authorized.ok)
-            return toCallToolResult(authorized, queryContract);
-        const result = await logToolExecution(options.logger, queryContract.name, () => queryReconstructionCoverage(parsed.value, options.evidenceFilePolicy, Date.now(), { signal: context.mcpReq.signal }));
-        if (result.ok && options.retainCoverageWorkspace !== undefined) {
-            const closure = reconstructionClosureResultSchema.parse(result.value);
-            const loaded = await readReconstructionCoverageWorkspace(parsed.value.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,25 +1,21 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstructionObligationLedgerRequest, } from "../../application/ReconstructionObligationLedgerService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionObligationLedgerInputSchema } from "../../domain/reconstructionObligationLedgerSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.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) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = safeParseToolInput(reconstructionObligationLedgerInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const resolved = resolveReconstructionObligationLedgerRequest(parsed.value);
+        const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         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,28 +1,19 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
-import { resolveTraceApplicationFeatureRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { traceApplicationFeatureRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { toCallToolResult } from "../toolResult.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 parsedInput = safeParseToolInput(traceApplicationFeatureRequestSchema, input, traceContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, traceContract);
-        const resolved = resolveTraceApplicationFeatureRequestValidated(parsedInput.value, 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);