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)

src/domain/javascript/javascriptRuntimeReconciliation.ts

@@ -2,21 +2,23 @@ import { classifyStaticLoadStates } from "./javascriptRuntimeLoadState.js";
 import { buildReconciledApplicationGraph } from "./javascriptRuntimeReconciliationGraph.js";
 import { reconcileRuntimeEntities } from "./javascriptRuntimeReconciliationMatching.js";
 import {
-  parseStaticLayers,
+  parseStaticLayer,
   type ParsedStaticLayer,
 } from "./javascriptRuntimeReconciliationParsing.js";
 import {
-  parseRuntimeCaptures,
+  parseRuntimeCapture,
   type ParsedRuntimeCapture,
 } from "./javascriptRuntimeReconciliationCaptureParsing.js";
 import { createJavaScriptRuntimeReconciliationResult } from "./javascriptRuntimeReconciliationResult.js";
 import type {
   JavaScriptRuntimeReconciliationResult,
+  ReconcileJavaScriptRuntimeFrame,
   ReconcileJavaScriptRuntimeInput,
 } from "./javascriptRuntimeReconciliationSchemas.js";
 import { projectRuntimeCaptures } from "./javascriptRuntimeReconciliationRuntime.js";
 import { collectStaticRuntimeCandidates } from "./javascriptRuntimeStaticCandidates.js";
 import { AnalysisInputError } from "../analysisErrorCore.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { err, ok, type Result } from "../result.js";
 
 /** Verified caller input and the static and runtime facts parsed from it. */
@@ -28,15 +30,48 @@ export interface ParsedRuntimeReconciliationInput {
 
 /** Parse caller Evidence once into the owner consumed by reconciliation. */
 export const readRuntimeReconciliationInput = (
-  input: ReconcileJavaScriptRuntimeInput,
+  input: ReconcileJavaScriptRuntimeFrame,
 ): Result<ParsedRuntimeReconciliationInput, AnalysisInputError> => {
   try {
+    const layers: ParsedStaticLayer[] = [];
+    const captures: ParsedRuntimeCapture[] = [];
+    // Preserve caller source order in Evidence parameters while the algorithm
+    // consumes deterministically sorted facts. Only authenticated records enter
+    // the canonical input returned to the Evidence constructor.
+    const staticLayers = input.static_layers.map((layer, index) => {
+      const parsed = parseStaticLayer(layer, [
+        "static_layers",
+        index,
+        "analysis",
+      ]);
+      layers.push(parsed);
+      return { ...layer, analysis: parsed.evidence };
+    });
+    const runtimeObservations = input.runtime_observations.map(
+      (observation, index) => {
+        const parsed = parseRuntimeCapture(observation, [
+          "runtime_observations",
+          index,
+        ]);
+        captures.push(parsed);
+        return parsed.evidence;
+      },
+    );
     return ok({
-      input,
-      layers: parseStaticLayers(input.static_layers, ["static_layers"]),
-      captures: parseRuntimeCaptures(input.runtime_observations, [
-        "runtime_observations",
-      ]),
+      input: {
+        ...input,
+        static_layers: staticLayers,
+        runtime_observations: runtimeObservations,
+      },
+      layers: layers.sort((left, right) =>
+        compareUnicodeCodePoints(left.layerId, right.layerId),
+      ),
+      captures: captures.sort((left, right) =>
+        compareUnicodeCodePoints(
+          left.evidence.evidence_id,
+          right.evidence.evidence_id,
+        ),
+      ),
     });
   } catch (cause: unknown) {
     if (cause instanceof AnalysisInputError) return err(cause);