refactor(evidence): unify retained inputs across domains (#8299)

Declare logical Evidence sources once and resolve exact retained inputs through
shared application workflows across 20 composition tools. Preserve domain-owned
authentication, source closure, caller choices, coverage and resource admission.

Validation includes public CLI/MCP regressions, local Codex terra/high trials
and fresh-import real-artifact workflows. Measurements, failed attempts and
coverage limits are recorded in docs/verification/evidence-input-composition-2026-10-31.md.

Fixes #8293.
Fixes #8281.

Assisted-by: Suika (gensokyo-skills:suika-scatter-gather-planning)
This commit is contained in:
gensokyo-dev authored and GitHub committed 2026-10-31 14:45:21 +00:00
1 parent 23de10bb28
commit a989c0e458
114 files changed
+8532 -1383

No files matched your search

@@ -1,39 +1,39 @@
import type { ExecutionOptions } from "../AnalysisProvider.js";
import {
resolveEvidenceInput,
resolveEvidenceRequest,
type EvidenceLookup,
} from "../EvidenceInputResolver.js";
import { retainedEvidenceReferenceSchema } from "../../domain/evidenceReference.js";
import { parseAnalysisInput } from "../AnalysisInput.js";
import {
compareApplicationVersionsRequestSchema,
compareJavaScriptExportShapesRequestSchema,
compareSourceToBundleCliInputSchema,
compareSourceToBundleRequestSchema,
traceApplicationFeatureRequestSchema,
} from "../../contracts/javascript/applicationWorkflowInputContracts.js";
import type { EvidenceWorkflowExecution } from "../investigation/EvidenceWorkflowExecution.js";
import type { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
import type { ResolvedSourceToBundleReference } from "./SourceToBundleReference.js";
import { z } from "zod";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import type { Evidence } from "../../domain/evidence.js";
import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
import { compareJavaScriptApplicationVersions } from "../../domain/javascript/javascriptApplicationVersionComparison.js";
import {
compareApplicationVersionsInputSchema,
applicationVersionIdentitiesSchema,
type ApplicationVersionComparisonResult,
} from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
import { compareJavaScriptExportShapes } from "../../domain/javascript/javascriptExportShapeComparison.js";
import {
compareJavaScriptExportShapesInputSchema,
javaScriptExportShapeIdentitiesSchema,
type JavaScriptExportShapeComparisonResult,
} from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
import { traceApplicationFeature } from "../../domain/javascript/javascriptFeatureTrace.js";
import {
traceApplicationFeatureInputSchema,
applicationTraceIdentitiesSchema,
type ApplicationFeatureTraceResult,
} from "../../domain/javascript/javascriptFeatureTraceSchemas.js";
import { err, ok, type Result } from "../../domain/result.js";
import { compareSourceToBundle } from "../../domain/javascript/sourceToBundleComparison.js";
import {
compareSourceToBundleInputSchema,
type SourceToBundleComparisonResult,
} from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
import type { SourceToBundleComparisonResult } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
import {
applicationGraphEvidenceInputError,
parseApplicationGraphEvidence,
@@ -48,68 +48,32 @@ import {
} from "./JavaScriptApplicationWorkflowEvidence.js";
/** Completed workflow facts and authenticated sources retained for adapter delivery. */
export interface ApplicationWorkflowExecution<Projection> {
readonly evidence: Evidence;
export interface ApplicationWorkflowExecution<
Projection,
> extends EvidenceWorkflowExecution {
readonly result: Projection;
readonly sources: readonly Evidence[];
}
// Validate the request frame without cloning source payloads before their owner reads them.
const featureTraceFrameSchema = z.strictObject({
...traceApplicationFeatureInputSchema.shape,
application: z.unknown().nonoptional(),
native_observations: z.array(z.unknown()).default([]),
});
const versionComparisonFrameSchema = z.strictObject({
...compareApplicationVersionsInputSchema.shape,
left: z.unknown().nonoptional(),
right: z.unknown().nonoptional(),
left_native_observations: z.array(z.unknown()).default([]),
right_native_observations: z.array(z.unknown()).default([]),
});
const exportShapeFrameSchema = z.strictObject({
...compareJavaScriptExportShapesInputSchema.shape,
left: z.unknown().nonoptional(),
right: z.unknown().nonoptional(),
});
const resolveWorkflowEvidence = (
raw: unknown,
lookup: EvidenceLookup | undefined,
): Result<unknown, AnalysisError> => {
const reference = retainedEvidenceReferenceSchema.safeParse(raw);
return reference.success
? resolveEvidenceInput(reference.data, lookup)
: ok(raw);
};
/** Resolve both selections before authenticating either graph, retaining diagnostic inputs. */
const resolveApplicationGraphPair = (
/** Authenticate the resolved graph pair at the owning domain boundary. */
const parseApplicationGraphPair = (
operation: string,
input: { readonly left: unknown; readonly right: unknown },
lookup: EvidenceLookup | undefined,
): Result<
{
readonly left: ApplicationGraphEvidenceSource;
readonly right: ApplicationGraphEvidenceSource;
readonly selected: { readonly left: unknown; readonly right: unknown };
},
AnalysisError
> => {
const selectedLeft = resolveWorkflowEvidence(input.left, lookup);
if (!selectedLeft.ok) return selectedLeft;
const selectedRight = resolveWorkflowEvidence(input.right, lookup);
if (!selectedRight.ok) return selectedRight;
const left = parseApplicationGraphEvidence(selectedLeft.value, ["left"]);
const left = parseApplicationGraphEvidence(input.left, ["left"]);
if (!left.ok)
return err(applicationGraphEvidenceInputError(operation, left.error));
const right = parseApplicationGraphEvidence(selectedRight.value, ["right"]);
const right = parseApplicationGraphEvidence(input.right, ["right"]);
if (!right.ok)
return err(applicationGraphEvidenceInputError(operation, right.error));
return ok({
left: left.value,
right: right.value,
selected: { left: selectedLeft.value, right: selectedRight.value },
});
};
@@ -117,20 +81,21 @@ const resolveApplicationGraphPair = (
export const traceApplicationFeatureEvidence = (
rawInput: unknown,
lookup?: EvidenceLookup,
options: Pick<ExecutionOptions, "signal"> = {},
): Result<
ApplicationWorkflowExecution<ApplicationFeatureTraceResult>,
AnalysisError
> => {
const operation = "trace_application_feature";
const request = parseAnalysisInput(
const request = resolveEvidenceRequest(
operation,
rawInput,
featureTraceFrameSchema,
traceApplicationFeatureRequestSchema,
lookup,
options,
);
if (!request.ok) return request;
const selected = resolveWorkflowEvidence(request.value.application, lookup);
if (!selected.ok) return selected;
const input = { ...request.value, application: selected.value };
const input = request.value.input;
const sourceResult = parseApplicationGraphEvidence(input.application, [
"application",
]);
@@ -189,21 +154,24 @@ export const traceApplicationFeatureEvidence = (
export const compareApplicationVersionsEvidence = (
rawInput: unknown,
lookup?: EvidenceLookup,
options: Pick<ExecutionOptions, "signal"> = {},
): Result<
ApplicationWorkflowExecution<ApplicationVersionComparisonResult>,
AnalysisError
> => {
const operation = "compare_application_versions";
const request = parseAnalysisInput(
const request = resolveEvidenceRequest(
operation,
rawInput,
versionComparisonFrameSchema,
compareApplicationVersionsRequestSchema,
lookup,
options,
);
if (!request.ok) return request;
const pair = resolveApplicationGraphPair(operation, request.value, lookup);
const input = request.value.input;
const pair = parseApplicationGraphPair(operation, input);
if (!pair.ok) return pair;
const { left, right } = pair.value;
const input = { ...request.value, ...pair.value.selected };
const leftNativeResult = parseNativeApplicationEvidence(
input.left_native_observations,
["left_native_observations"],
@@ -262,10 +230,47 @@ export const compareApplicationVersionsEvidence = (
});
};
/** Compare source and bundle inputs already parsed by a trusted adapter. */
export const compareSourceToBundleEvidence = (
input: ResolvedSourceToBundleReference &
Pick<z.output<typeof compareSourceToBundleInputSchema>, "application">,
/** Select the application record and historical graph through their shared owners. */
export const executeSourceToBundleComparison = async (
rawInput: unknown,
schema:
| typeof compareSourceToBundleCliInputSchema
| typeof compareSourceToBundleRequestSchema,
lookup: EvidenceLookup | undefined,
resources: ArtifactResourceScope,
options: Pick<ExecutionOptions, "signal"> = {},
): Promise<
Result<
ApplicationWorkflowExecution<SourceToBundleComparisonResult>,
AnalysisError
>
> => {
const selected = resolveEvidenceRequest(
"compare_source_to_bundle",
rawInput,
schema,
lookup,
options,
);
if (!selected.ok) return selected;
const { resolveSourceToBundleReference } =
await import("./SourceToBundleReference.js");
const reference = await resolveSourceToBundleReference(
selected.value.input.reference,
options.signal,
resources,
);
return reference.ok
? compareSourceToBundleEvidence({
...reference.value,
application: selected.value.input.application,
})
: reference;
};
/** Compare an owner-parsed historical graph with an unadmitted application source. */
const compareSourceToBundleEvidence = (
input: ResolvedSourceToBundleReference & { readonly application: unknown },
): Result<
ApplicationWorkflowExecution<SourceToBundleComparisonResult>,
AnalysisError
@@ -307,21 +312,24 @@ export const compareSourceToBundleEvidence = (
export const compareJavaScriptExportShapesEvidence = (
rawInput: unknown,
lookup?: EvidenceLookup,
options: Pick<ExecutionOptions, "signal"> = {},
): Result<
ApplicationWorkflowExecution<JavaScriptExportShapeComparisonResult>,
AnalysisError
> => {
const operation = "compare_javascript_export_shapes";
const request = parseAnalysisInput(
const request = resolveEvidenceRequest(
operation,
rawInput,
exportShapeFrameSchema,
compareJavaScriptExportShapesRequestSchema,
lookup,
options,
);
if (!request.ok) return request;
const pair = resolveApplicationGraphPair(operation, request.value, lookup);
const input = request.value.input;
const pair = parseApplicationGraphPair(operation, input);
if (!pair.ok) return pair;
const { left, right } = pair.value;
const input = { ...request.value, ...pair.value.selected };
const identities = javaScriptExportShapeIdentitiesSchema.safeParse({
left: left.evidence,
right: right.evidence,