rea-agents 3.0.0 → 3.2.0

package/dist/server/registerEnhancedTools.js

@@ -1,146 +1,138 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
-import { enhancedInputSchemas, enhancedToolNameSchema, } from "../contracts/enhancedInputs.js";
+import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
 import { ENHANCED_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
-import { logToolExecution } from "./toolLogging.js";
+import { UnknownRegistryError } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
-import { AnalysisInputError, UnknownRegistryError } from "../domain/errors.js";
-import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
+import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+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) => {
-    for (const contract of ENHANCED_TOOL_CONTRACTS) {
-        registerEnhancedTool(server, analysis, contract, {
-            logger: options.logger,
-            activeTarget: options.activeTarget,
-            analysisProfile: options.analysisProfile,
-            recordEvidence: options.recordEvidence,
-            recordUnknown: options.recordUnknown,
-        });
-    }
+    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, {
+        validatedCall: { name: "get_objc_classes", input },
+        context,
+    }));
+    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(analysis, options, objcProtocols, {
+        validatedCall: { name: "get_objc_protocols", input },
+        context,
+    }));
+    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(analysis, options, batchDecompile, {
+        validatedCall: { name: "batch_decompile", input },
+        context,
+    }));
+    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(analysis, options, callGraph, {
+        validatedCall: { name: "get_call_graph", input },
+        context,
+    }));
+    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(analysis, options, swiftTypes, {
+        validatedCall: { name: "analyze_swift_types", input },
+        context,
+    }));
+    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(analysis, options, xrefsToName, {
+        validatedCall: { name: "find_xrefs_to_name", input },
+        context,
+    }));
+    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(analysis, options, binaryOverview, {
+        validatedCall: { name: "binary_overview", input },
+        context,
+    }));
+    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(analysis, options, analyzeFunction, {
+        validatedCall: { name: "analyze_function", input },
+        context,
+    }));
+    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(analysis, options, inspectNativeApi, {
+        validatedCall: { name: "inspect_native_api", input },
+        context,
+    }));
+    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(analysis, options, traceFeature, {
+        validatedCall: { name: "trace_feature", input },
+        context,
+    }));
+    server.registerTool(codeForString.name, toolRegistrationOptions(codeForString), (input, context) => executeEnhancedTool(analysis, options, codeForString, {
+        validatedCall: { name: "find_code_for_string", input },
+        context,
+    }));
+    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, options, traceCallPath, {
+        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 registerEnhancedTool = (server, analysis, contract, registration) => {
-    const name = enhancedToolNameSchema.parse(contract.name);
-    server.registerTool(name, toolRegistrationOptions(contract), async (input, context) => {
-        const progress = mcpProgressReporter(context);
-        await progress.report({
-            phase: name,
-            completed: 0,
-            total: 1,
-            message: "started",
-        });
-        const validatedCall = parseEnhancedCall(name, input);
-        if (!validatedCall.ok)
-            return toCallToolResult(validatedCall, contract);
-        const parsedInput = validatedCall.value.input;
-        const parameters = jsonParameters(parsedInput);
-        const services = new EnhancedTools({
-            execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
-                ...executionOptions,
-                progress,
-            }),
+const executeEnhancedTool = async (analysis, registration, contract, request) => {
+    const { validatedCall, context } = request;
+    const name = validatedCall.name;
+    const progress = mcpProgressReporter(context);
+    await progress.report({
+        phase: name,
+        completed: 0,
+        total: 1,
+        message: "started",
+    });
+    const parsedInput = validatedCall.input;
+    const parameters = jsonParameters(parsedInput);
+    const services = new EnhancedTools({
+        execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
+            ...executionOptions,
+            progress,
+        }),
+    });
+    const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall, context.mcpReq.signal));
+    await progress.report({
+        phase: name,
+        completed: 1,
+        total: 1,
+        message: result.ok ? "completed" : "failed",
+        terminal: true,
+    });
+    if (result.ok) {
+        const upstreamProfile = registration.analysisProfile?.();
+        const evidence = createEvidence(registration.activeTarget?.(), REA_WORKFLOW_PROVIDER, {
+            operation: name,
+            parameters,
+            result: result.value,
+            ...(upstreamProfile === undefined
+                ? {}
+                : {
+                    analysisProfile: workflowAnalysisProfile(upstreamProfile),
+                }),
+            confidence: "derived",
+            limitations: [
+                "Derived by an REA workflow from one or more provider observations.",
+            ],
         });
-        const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall.value, context.mcpReq.signal));
-        await progress.report({
-            phase: name,
-            completed: 1,
-            total: 1,
-            message: result.ok ? "completed" : "failed",
-            terminal: true,
+        const recorded = registration.recordEvidence?.(evidence);
+        if (recorded !== undefined && !recorded.ok)
+            return toCallToolResult(recorded, contract);
+        const unknowns = recordWorkflowUnknowns({
+            name,
+            result: result.value,
+            evidenceId: evidence.evidence_id,
+            recordUnknown: registration.recordUnknown,
         });
-        if (result.ok) {
-            const upstreamProfile = registration.analysisProfile?.();
-            const evidence = createEvidence(registration.activeTarget?.(), REA_WORKFLOW_PROVIDER, {
-                operation: name,
-                parameters,
-                result: result.value,
-                ...(upstreamProfile === undefined
-                    ? {}
-                    : {
-                        analysisProfile: workflowAnalysisProfile(upstreamProfile),
-                    }),
-                confidence: "derived",
-                limitations: [
-                    "Derived by an REA workflow from one or more provider observations.",
-                ],
-            });
-            const recorded = registration.recordEvidence?.(evidence);
-            if (recorded !== undefined && !recorded.ok)
-                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(result, contract);
-    });
-};
-const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
-const ENHANCED_INPUT_PARSERS = {
-    swift_classes: (input) => safeParseToolInput(enhancedInputSchemas.swift_classes, input, "swift_classes"),
-    get_objc_classes: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_classes, input, "get_objc_classes"),
-    get_objc_protocols: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_protocols, input, "get_objc_protocols"),
-    batch_decompile: (input) => safeParseToolInput(enhancedInputSchemas.batch_decompile, input, "batch_decompile"),
-    get_call_graph: (input) => safeParseToolInput(enhancedInputSchemas.get_call_graph, input, "get_call_graph"),
-    analyze_swift_types: (input) => safeParseToolInput(enhancedInputSchemas.analyze_swift_types, input, "analyze_swift_types"),
-    find_xrefs_to_name: (input) => safeParseToolInput(enhancedInputSchemas.find_xrefs_to_name, input, "find_xrefs_to_name"),
-    binary_overview: (input) => safeParseToolInput(enhancedInputSchemas.binary_overview, input, "binary_overview"),
-    analyze_function: (input) => safeParseToolInput(enhancedInputSchemas.analyze_function, input, "analyze_function"),
-    inspect_native_api: (input) => safeParseToolInput(enhancedInputSchemas.inspect_native_api, input, "inspect_native_api"),
-    trace_feature: (input) => safeParseToolInput(enhancedInputSchemas.trace_feature, input, "trace_feature"),
-    find_code_for_string: (input) => safeParseToolInput(enhancedInputSchemas.find_code_for_string, input, "find_code_for_string"),
-    trace_call_path: (input) => safeParseToolInput(enhancedInputSchemas.trace_call_path, input, "trace_call_path"),
-};
-const parseEnhancedCall = (name, input) => {
-    switch (name) {
-        case "swift_classes":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.swift_classes(input), (value) => ({ name, input: value }));
-        case "get_objc_classes":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_classes(input), (value) => ({ name, input: value }));
-        case "get_objc_protocols":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_protocols(input), (value) => ({ name, input: value }));
-        case "batch_decompile":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.batch_decompile(input), (value) => ({ name, input: value }));
-        case "get_call_graph":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_call_graph(input), (value) => ({ name, input: value }));
-        case "analyze_swift_types":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_swift_types(input), (value) => ({ name, input: value }));
-        case "find_xrefs_to_name":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_xrefs_to_name(input), (value) => ({ name, input: value }));
-        case "binary_overview":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.binary_overview(input), (value) => ({ name, input: value }));
-        case "analyze_function":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_function(input), (value) => ({ name, input: value }));
-        case "inspect_native_api":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.inspect_native_api(input), (value) => ({ name, input: value }));
-        case "trace_feature":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_feature(input), (value) => ({ name, input: value }));
-        case "find_code_for_string":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_code_for_string(input), (value) => ({ name, input: value }));
-        case "trace_call_path":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_call_path(input), (value) => ({ name, input: value }));
+        if (!unknowns.ok)
+            return toCallToolResult(unknowns, contract);
+        return toCallToolResult({ ok: true, value: evidence }, contract);
     }
+    return toCallToolResult(result, contract);
 };
-const mapEnhancedCall = (parsed, project) => parsed.ok ? ok(project(parsed.value)) : parsed;
-const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown, }) => {
+const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
+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 ||
@@ -151,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",
@@ -165,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,13 +1,13 @@
+import { projectPermissionFailure } from "../application/PermissionFailure.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { err } from "../domain/result.js";
+import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { mcpProgressReporter } from "./mcpProgress.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { err } from "../domain/result.js";
-/** Register provider-backed contracts that return atomic Evidence v2 observations. */
+import { toCallToolResult } from "./toolResult.js";
+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,23 +18,22 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 total: 1,
                 message: "started",
             });
-            const parsedInput = safeParseToolInput(contract.inputSchema, input, contract.name);
-            if (!parsedInput.ok)
-                return toCallToolResult(parsedInput, contract);
-            const parameters = jsonObjectSchema.parse(parsedInput.value);
+            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,
             }));
@@ -65,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,44 +1,47 @@
-import { compareFunctions, functionComparisonInputSchema, } from "../domain/functionComparison.js";
-import { createEvidence } from "../domain/evidence.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.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 { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.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 parsedInput = safeParseToolInput(functionComparisonInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const expected = {
-            operation: "analyze_function",
-            predicate: "rea.analysis/v2",
-        };
-        const left = resolveSessionEvidenceIds(session, parsed.left_evidence_ids, expected);
-        if (!left.ok)
-            return toCallToolResult(left, contract);
-        const right = resolveSessionEvidenceIds(session, parsed.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, parsed.offset, parsed.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: parsed.offset,
-                limit: parsed.limit,
+                left_evidence_id: leftEvidence.evidence_id,
+                right_evidence_id: rightEvidence.evidence_id,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -47,7 +50,6 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             evidenceLinks: [...leftIds, ...rightIds],
         });
         const recorded = recordDerivedEvidence(session, evidence, functionUnknownInput({
-            approved: parsed.unknown_registry_approved,
             status: comparison.status,
             leftIds,
             rightIds,
@@ -55,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",
@@ -71,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,