rea-agents 6.4.0 → 6.7.0

package/dist/application/WebModuleTraceService.js

@@ -1,3 +1,5 @@
+import { closeOwnedWebResources } from "./closeOwnedWebResources.js";
+import { isDeepStrictEqual } from "node:util";
 import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
@@ -6,9 +8,10 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { err, ok } from "../domain/result.js";
 import { collectWebModuleImports, matchCapturedModules, } from "../domain/webModuleImports.js";
-import { webModuleTraceInputSchema, webModuleFileSchema, webModuleResolutionSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
+import { webModuleTraceInputSchema, webModuleFileSchema, webModuleResolutionBatchSchema, webModuleResolutionObservationSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
 import { selectedWebScriptArtifactsSchema } from "../domain/webScriptArtifacts.js";
 import { capturedWebManifestIdentity, validateSelectedWebScript, } from "./ValidateSelectedWebScript.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 const OPERATION = "trace_web_module_imports";
 const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
     importMap: z
@@ -19,12 +22,6 @@ const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
     })
         .nullable(),
 });
-const resolutionBatchSchema = z.strictObject({
-    engine: z.strictObject({ id: z.string().min(1), version: z.string().min(1) }),
-    resolutions: z.array(webModuleResolutionSchema),
-    diagnostics: z.array(z.string()),
-    rawResult: jsonObjectSchema,
-});
 const LIMITATIONS = [
     "Resolution is derived under the selected importer URL and optional import map; it does not establish that the map was installed in the captured page.",
     "Reported source URLs do not establish an inline script's document base. Select importer_url explicitly when that context differs or is unknown.",
@@ -43,9 +40,15 @@ export class WebModuleTraceService {
         this.artifacts = artifacts;
         this.resolver = resolver;
     }
+    close() {
+        return closeOwnedWebResources([
+            this.artifacts.close?.bind(this.artifacts),
+            this.resolver.close?.bind(this.resolver),
+        ], "Web module trace cleanup failed");
+    }
     async trace(rawInput, options) {
-        if (isAborted(options?.signal))
-            return err(new AnalysisCancelledError(OPERATION));
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION, { cause: options.signal.reason }));
         const parsed = webModuleTraceInputSchema.safeParse(rawInput);
         if (!parsed.success)
             return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput, {
@@ -91,8 +94,13 @@ export class WebModuleTraceService {
             .filter((reference) => reference.specifier !== null)
             .map((reference) => reference.specifier ?? "");
         let resolution = null;
+        let resolutionFailure;
         if (literals.length > 0) {
-            const execution = await this.resolver.resolve({
+            if (options?.signal?.aborted)
+                return err(new AnalysisCancelledError(OPERATION, {
+                    cause: options.signal.reason,
+                }));
+            const request = {
                 importerUrl,
                 importMap: data.importMap === null
                     ? null
@@ -101,18 +109,26 @@ export class WebModuleTraceService {
                         value: data.importMap.value,
                     },
                 specifiers: literals,
-            }, options);
-            if (!execution.ok)
-                return execution;
-            const report = resolutionBatchSchema.safeParse(execution.value);
-            if (!report.success)
-                return err(new AnalysisOutputError(OPERATION, "Resolver returned malformed or incomplete native evidence."));
-            resolution = report.data;
+            };
+            const execution = await this.resolver.resolve(request, options);
+            if (execution.ok) {
+                const report = webModuleResolutionBatchSchema.safeParse(execution.value);
+                if (!report.success)
+                    return err(new AnalysisOutputError(OPERATION, "Resolver returned malformed or incomplete native evidence."));
+                resolution = report.data;
+            }
+            else {
+                const observation = webModuleResolutionObservationSchema.safeParse(execution.error.partialObservation);
+                if (!observation.success ||
+                    !isDeepStrictEqual(observation.data.request, request) ||
+                    observation.data.batch.resolutions.length !== literals.length)
+                    return execution;
+                resolution = observation.data.batch;
+                resolutionFailure = execution.error;
+            }
             if (resolution.resolutions.length !== literals.length)
                 return err(new AnalysisOutputError(OPERATION, "Resolver did not return every selected literal specifier."));
         }
-        if (isAborted(options?.signal))
-            return err(new AnalysisCancelledError(OPERATION));
         let literalIndex = 0;
         const imports = [];
         for (const reference of syntax.imports) {
@@ -162,7 +178,7 @@ export class WebModuleTraceService {
         });
         if (!normalized.success)
             return err(new AnalysisOutputError(OPERATION, normalized.error.message));
-        return ok(createEvidence({
+        const evidence = createEvidence({
             path: data.sourceFile.path,
             sha256: data.sourceFile.sha256,
             format: "file",
@@ -185,7 +201,12 @@ export class WebModuleTraceService {
             evidenceLinks: data.manifest.source_evidence_id === null
                 ? []
                 : [data.manifest.source_evidence_id],
-        }));
+        });
+        if (resolutionFailure !== undefined) {
+            resolutionFailure.partialObservation = evidence;
+            return err(resolutionFailure);
+        }
+        return completeProviderEvidence(evidence, options?.signal);
     }
 }
 const admitContext = (value, path) => {
@@ -205,7 +226,6 @@ const admitContext = (value, path) => {
         }));
     return ok(null);
 };
-const isAborted = (signal) => signal?.aborted === true;
 const invalid = (path, message) => err(new AnalysisInputError(OPERATION, undefined, [
     { path, reason: "invalid_format", message },
 ]));

package/dist/application/WebNetworkCaptureService.js

@@ -3,11 +3,13 @@ import { excludeCaptureCoordinates } from "../domain/webNetworkCaptureCoordinate
 import { redactExplicitText } from "../domain/explicitSensitiveValues.js";
 import { isAbsolute } from "node:path";
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { createAnalysisProfile } from "../domain/analysisProfile.js";
 import { createEvidence } from "../domain/evidence.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-import { inspectWebNetworkCaptureInputSchema, webNetworkCaptureSchema, } from "../domain/webNetworkCapture.js";
+import { inspectWebNetworkCaptureInputSchema, captureSensitiveValues, webNetworkCaptureSchema, } from "../domain/webNetworkCapture.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 const OPERATION = "inspect_web_network_capture";
 /** Shared CLI/MCP historical inspection preserves caller selection and producer record identity. */
 export class WebNetworkCaptureService {
@@ -15,16 +17,15 @@ export class WebNetworkCaptureService {
     constructor(port) {
         this.port = port;
     }
+    /** Release resources retained by the selected capture adapter. */
+    close() {
+        return this.port.close?.() ?? Promise.resolve();
+    }
     /** Return selected complete records inline, without inventing live browser attribution. */
     async inspect(rawInput, options) {
         if (options?.signal?.aborted)
             return err(new AnalysisCancelledError(OPERATION));
-        const declarations = inspectWebNetworkCaptureInputSchema.shape.sensitive_values.safeParse(typeof rawInput === "object" &&
-            rawInput !== null &&
-            "sensitive_values" in rawInput
-            ? rawInput.sensitive_values
-            : undefined);
-        const failure = (error) => err(redactExplicitFailure(error, declarations.success ? declarations.data : []));
+        const failure = (error) => err(redactExplicitFailure(error, captureSensitiveValues(rawInput)));
         const parsed = inspectWebNetworkCaptureInputSchema.safeParse(rawInput);
         if (!parsed.success)
             return failure(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput, {
@@ -51,8 +52,6 @@ export class WebNetworkCaptureService {
         const loaded = await this.port.inspect(input, options);
         if (!loaded.ok)
             return failure(loaded.error);
-        if (options?.signal?.aborted)
-            return failure(new AnalysisCancelledError(OPERATION));
         const report = webNetworkCaptureSchema.safeParse(loaded.value);
         if (!report.success)
             return failure(new AnalysisOutputError(OPERATION, "Capture adapter returned malformed historical evidence."));
@@ -107,7 +106,7 @@ export class WebNetworkCaptureService {
             record_ordinals: selected,
             sensitive_value_count: input.sensitive_values.length,
         });
-        return ok(createEvidence(safeSha256 === null
+        return completeProviderEvidence(createEvidence(safeSha256 === null
             ? undefined
             : {
                 path: safePath,
@@ -118,17 +117,30 @@ export class WebNetworkCaptureService {
             parameters,
             result: {
                 ...safeValue,
-                artifact: { ...value.artifact, path: safePath, sha256: safeSha256 },
+                artifact: {
+                    ...value.artifact,
+                    path: safePath,
+                    sha256: safeSha256,
+                },
                 records,
                 limitations: safeSha256 === null
                     ? [...limitations, subjectUnavailableReason]
                     : limitations,
             },
+            ...(safeValue.format !== "qlog"
+                ? {}
+                : {
+                    analysisProfile: createAnalysisProfile(value.decoder, {
+                        qlog_profile: safeValue.qlog.profile,
+                        clock: safeValue.qlog.clock,
+                        scope: safeValue.qlog.scope,
+                    }),
+                }),
             confidence: "observed",
             authority: "historical-reference",
             limitations,
             ...(safeSha256 === null ? { subjectUnavailableReason } : {}),
             locations: safePath === "" ? [] : [{ kind: "artifact-path", path: safePath }],
-        }));
+        }), options?.signal);
     }
 }

package/dist/application/WebRuntimeService.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { createEvidence } from "../domain/evidence.js";
-import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { err, ok } from "../domain/result.js";
 import { observeWebExecutionInputSchema, webExecutionSchema, } from "../domain/webExecution.js";
 import { inspectWebEventListenersInputSchema, webEventListenersSchema, } from "../domain/webEventListeners.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 /** Shared public workflows keep instrumentation and listener inspection independently selectable. */
 export class WebRuntimeService {
     provider;
@@ -19,8 +20,25 @@ export class WebRuntimeService {
         if (!parsed.ok)
             return parsed;
         const result = await this.provider.observeExecution(parsed.value, options);
-        if (!result.ok)
+        if (!result.ok) {
+            const partial = result.error.partialObservation;
+            if (partial !== undefined &&
+                !("evidence_id" in partial) &&
+                "instrumentation" in partial &&
+                "window" in partial) {
+                const verifiedPartial = webExecutionSchema.safeParse(partial);
+                if (verifiedPartial.success) {
+                    const evidence = this.evidence(operation, parsed.value, verifiedPartial.data);
+                    if (evidence.ok)
+                        result.error.partialObservation = evidence.value;
+                    else if (result.error instanceof AnalysisCancelledError)
+                        return evidence;
+                }
+                else if (result.error instanceof AnalysisCancelledError)
+                    return err(new AnalysisOutputError(operation, "Provider retained a malformed completed execution observation.", { cause: verifiedPartial.error }));
+            }
             return result;
+        }
         const verified = webExecutionSchema.safeParse(result.value);
         if (!verified.success)
             return err(new AnalysisOutputError(operation, verified.error.message));
@@ -36,8 +54,25 @@ export class WebRuntimeService {
         if (!parsed.ok)
             return parsed;
         const result = await this.provider.inspectEventListeners(parsed.value, options);
-        if (!result.ok)
+        if (!result.ok) {
+            const partial = result.error.partialObservation;
+            if (partial !== undefined &&
+                !("evidence_id" in partial) &&
+                "selected_node" in partial &&
+                "listeners" in partial) {
+                const verifiedPartial = webEventListenersSchema.safeParse(partial);
+                if (verifiedPartial.success) {
+                    const evidence = this.evidence(operation, parsed.value, verifiedPartial.data);
+                    if (evidence.ok)
+                        result.error.partialObservation = evidence.value;
+                    else if (result.error instanceof AnalysisCancelledError)
+                        return evidence;
+                }
+                else if (result.error instanceof AnalysisCancelledError)
+                    return err(new AnalysisOutputError(operation, "Provider retained malformed completed event-listener data.", { cause: verifiedPartial.error }));
+            }
             return result;
+        }
         const verified = webEventListenersSchema.safeParse(result.value);
         if (!verified.success)
             return err(new AnalysisOutputError(operation, verified.error.message));
@@ -47,20 +82,18 @@ export class WebRuntimeService {
         return this.evidence(operation, parsed.value, verified.data, options);
     }
     evidence(operation, input, result, options) {
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
         if (input.allowed_origins.length > 0 &&
             !input.allowed_origins.includes(result.target.origin))
             return err(new AnalysisOutputError(operation, "Provider returned a document outside the selected origin scope."));
-        return ok(createEvidence(undefined, this.provider.identity(), {
+        return completeProviderEvidence(createEvidence(undefined, this.provider.identity(), {
             predicateType: `rea.${operation.replaceAll("_", "-")}`,
             operation,
             parameters: jsonObjectSchema.parse(input),
-            result: jsonValueSchema.parse(result),
+            result,
             confidence: "observed",
             authority: "external-service",
             limitations: result.limitations,
-        }));
+        }), options?.signal);
     }
 }
 const parseInput = (schema, rawInput, operation, options) => {

package/dist/application/WebScriptExportService.js

@@ -126,16 +126,18 @@ const readCapture = async (path, resources, signal) => {
         return ok({ bytes: await readRegularFile(path, { signal }) });
     }
     catch (cause) {
+        if (signal?.aborted === true && cause === signal.reason)
+            return err(captureReadFailure(path, cause, signal));
         if (cause instanceof RegularFileCleanupFailure) {
-            const retry = await retryRegularFileCleanup(cause, resources);
+            const retry = await retryRegularFileCleanup(cause, resources, signal);
             const cleanup = {
                 reason: retry.cleanup?.reason ?? errorMessage(cause.cleanupCause),
                 incomplete: retry.cleanup !== undefined,
                 cause: cause.cleanupCause,
             };
-            if (cause.outcome.kind === "completed")
-                return ok({ bytes: cause.outcome.value, cleanup });
-            const primary = captureReadFailure(path, cause.outcome.cause, signal, retry.cleanup === undefined ? { cause: cause.cleanupCause } : undefined);
+            if (retry.outcome.kind === "completed")
+                return ok({ bytes: retry.outcome.value, cleanup });
+            const primary = captureReadFailure(path, retry.outcome.cause, signal, retry.cleanup === undefined ? { cause: cause.cleanupCause } : undefined);
             return err(retry.cleanup === undefined
                 ? primary
                 : incompleteCaptureCleanup(primary, path, cleanup));

package/dist/application/WebSourceLocationService.js

@@ -1,3 +1,4 @@
+import { closeOwnedWebResources } from "./closeOwnedWebResources.js";
 import { createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { z } from "zod";
@@ -10,6 +11,7 @@ import { selectedWebScriptArtifactsSchema, webArtifactFileSchema, } from "../dom
 import { WEB_SOURCE_MAP_LIMITS, webSourceLocationInputSchema, webSourceLocationResultSchema, webSourceMapReportSchema, } from "../domain/webSourceLocation.js";
 import { webSourceOffset } from "../domain/webSourcePosition.js";
 import { capturedWebManifestIdentity, validateSelectedWebScript, } from "./ValidateSelectedWebScript.js";
+import { completeProviderEvidence } from "./ProviderOperationExecution.js";
 const OPERATION = "trace_web_source_location";
 const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
     sourceMap: z.strictObject({
@@ -25,8 +27,16 @@ const LIMITATIONS = [
     "Embedded source hashes identify the UTF-8 encoding of decoded sourcesContent text, not an independently retained original file. Missing or out-of-range original content positions remain explicit.",
     "Lookup returns all segments at the greatest generated position not greater than the selected point, including earlier lines and generated-only segments. A mapped point does not establish an executed range or UI causality.",
     "Regular maps and inline indexed sections are supported. External section URLs are unsupported; unknown extensions are retained in raw map text and are not interpreted.",
-    "Complete evidence has a 4 MiB map, 32 MiB reply, 262144 decoded rows/segments and 64-level section budget. The owned codec has a 20-second deadline, 192 MiB old-generation heap and one V8 worker; cleanup may extend the deadline. V8 heap limits do not establish aggregate RSS limits.",
 ];
+const CODEC_BUDGET = "Complete evidence has a 4 MiB map, 32 MiB reply, 262144 decoded rows/segments and 64-level section budget. The owned codec has a 20-second deadline";
+/** Bun accepts but ignores the codec's V8 heap flags; Windows enforces a commit limit instead. */
+const codecBudgetLimitation = (runtime) => {
+    if (runtime.id === "node-v8")
+        return `${CODEC_BUDGET}, ${String(WEB_SOURCE_MAP_LIMITS.codecHeapMiB)} MiB old-generation heap and one V8 worker; cleanup may extend the deadline. V8 heap limits do not establish aggregate RSS limits.`;
+    return runtime.process_memory_limit_bytes === null
+        ? `${CODEC_BUDGET}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags, so no codec heap limit is established.`
+        : `${CODEC_BUDGET}; cleanup may extend the deadline. The codec ran on Bun, which does not enforce REA's V8 heap flags; a Windows Job Object limited its committed memory to ${String(runtime.process_memory_limit_bytes)} bytes, which is not a heap or RSS limit.`;
+};
 /** Join verified captured bytes with an explicitly selected source-map point. */
 export class WebSourceLocationService {
     artifacts;
@@ -36,7 +46,10 @@ export class WebSourceLocationService {
         this.decoder = decoder;
     }
     close() {
-        return this.decoder.close?.() ?? Promise.resolve();
+        return closeOwnedWebResources([
+            this.artifacts.close?.bind(this.artifacts),
+            this.decoder.close?.bind(this.decoder),
+        ], "Web source-location cleanup failed");
     }
     /** Shared CLI/MCP workflow preserves raw declarations and every equal-position match. */
     async trace(rawInput, options) {
@@ -79,8 +92,10 @@ export class WebSourceLocationService {
         const report = verifyReport(input, map.file.sha256, traced.value);
         if (!report.ok)
             return report;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
+        const limitations = [
+            ...LIMITATIONS,
+            codecBudgetLimitation(report.value.runtime),
+        ];
         const normalized = webSourceLocationResultSchema.safeParse({
             ...report.value,
             manifest: capturedWebManifestIdentity(data),
@@ -93,11 +108,11 @@ export class WebSourceLocationService {
             generated_offset: generatedOffset,
             source_authenticity: "unknown",
             execution: "unknown",
-            limitations: LIMITATIONS,
+            limitations,
         });
         if (!normalized.success)
             return invalidOutput(normalized.error.message);
-        return ok(createEvidence({
+        return completeProviderEvidence(createEvidence({
             path: data.sourceFile.path,
             sha256: data.sourceFile.sha256,
             format: "file",
@@ -112,7 +127,7 @@ export class WebSourceLocationService {
             rawResult: { source_map_text: map.text },
             confidence: "derived",
             authority: "historical-reference",
-            limitations: LIMITATIONS,
+            limitations,
             locations: [
                 data.sourceFile.path,
                 data.manifestFile.path,
@@ -121,7 +136,7 @@ export class WebSourceLocationService {
             evidenceLinks: data.manifest.source_evidence_id === null
                 ? []
                 : [data.manifest.source_evidence_id],
-        }));
+        }), options?.signal);
     }
 }
 const invalidOutput = (message) => err(new AnalysisOutputError(OPERATION, message));

package/dist/application/WindowsCapabilities.js

@@ -26,21 +26,24 @@ export const probeWindowsCapabilities = async (dependencies = systemDependencies
             windowsNativeCapabilities(dependencies.platform),
     };
 };
-const systemDependencies = () => ({
-    platform: process.platform,
-    architecture: process.arch,
-    probeSymlinkCreation,
-    probeNoFollowOpen: () => systemNoFollowOpenCapability(process.platform, constants.O_NOFOLLOW),
-    probePrivateAcl: () => windowsNativeCapabilities(process.platform).private_runtime_dacl,
-    nativeCapabilities: () => windowsNativeCapabilities(process.platform),
-    probeUnixDomainSocket: () => process.platform === "win32"
-        ? {
-            available: false,
-            reason: "Node path-based IPC uses named pipes on Windows",
-        }
-        : { available: true, reason: null },
-    probePty: probeProcessCaptureCapability,
-});
+const systemDependencies = () => {
+    const security = windowsNativeCapabilities(process.platform);
+    return {
+        platform: process.platform,
+        architecture: process.arch,
+        probeSymlinkCreation,
+        probeNoFollowOpen: () => systemNoFollowOpenCapability(process.platform, constants.O_NOFOLLOW),
+        probePrivateAcl: () => security.private_runtime_dacl,
+        nativeCapabilities: () => security,
+        probeUnixDomainSocket: () => process.platform === "win32"
+            ? {
+                available: false,
+                reason: "Node path-based IPC uses named pipes on Windows",
+            }
+            : { available: true, reason: null },
+        probePty: probeProcessCaptureCapability,
+    };
+};
 /** Report pathname no-follow support without treating it as Windows authority. */
 export const systemNoFollowOpenCapability = (platform, noFollow) => {
     if (platform === "win32")

package/dist/application/WorkflowEvidence.js

@@ -1,7 +1,34 @@
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
+import { ok } from "../domain/result.js";
 import { analysisProfileSchema, committedProviderSchema, } from "../domain/analysisProfile.js";
 import { createEvidence, } from "../domain/evidence.js";
 import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
+import { renderSourceLimitations, sourceLimitationKey, } from "./SourceLimitations.js";
+/** Retain the limits of exactly the observations used by one composed call. */
+export const executeComposedWorkflow = async (analysis, execute) => {
+    const limitations = new Map();
+    const result = await execute({
+        execute: async (operation, parameters, options) => {
+            const execution = await analysis.execute(operation, parameters, options);
+            if (execution.ok)
+                for (const limitation of execution.value.limitations) {
+                    const fact = {
+                        provider: execution.value.provider,
+                        operation,
+                        limitation,
+                    };
+                    limitations.set(sourceLimitationKey(fact), fact);
+                }
+            return execution;
+        },
+    });
+    if (!result.ok)
+        return result;
+    return ok({
+        result: result.value,
+        limitations: renderSourceLimitations([...limitations.values()]),
+    });
+};
 /** Build the shared Evidence record for a successful composed binary workflow. */
 export const createWorkflowEvidence = (input) => createEvidence(input.target, REA_WORKFLOW_PROVIDER, {
     operation: input.operation,
@@ -13,7 +40,10 @@ export const createWorkflowEvidence = (input) => createEvidence(input.target, RE
             analysisProfile: workflowAnalysisProfile(input.upstreamProfile, input.operation),
         }),
     confidence: "derived",
-    limitations: ["Derived by an REA composed workflow."],
+    limitations: [
+        "Derived by an REA composed workflow.",
+        ...input.upstreamLimitations,
+    ],
     ...(input.operation === "batch_decompile"
         ? { locations: batchProcedureLocations(input.result) }
         : {}),

package/dist/application/analysisView/AnalysisViewService.js

@@ -1,3 +1,4 @@
+import { INSPECT_ANALYSIS_VIEW_OPERATION } from "../../domain/analysisView/analysisViewErrors.js";
 import { z } from "zod";
 import { ANALYSIS_VIEW_PROVIDER } from "../InvestigationProviders.js";
 import { resolveEvidenceInput } from "../EvidenceInputResolver.js";
@@ -5,9 +6,12 @@ import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCo
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
 import { createEvidence, parseEvidence, } from "../../domain/evidence.js";
-import { INSPECT_ANALYSIS_VIEW_OPERATION, inspectAnalysisViewInputSchema, projectAnalysisView, } from "../../domain/analysisView/analysisView.js";
+import { inspectAnalysisViewInputSchema, projectAnalysisView, } from "../../domain/analysisView/analysisView.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { isImmutableJsonSnapshot } from "../../domain/immutableJson.js";
 import { err, ok } from "../../domain/result.js";
+import { WebNetworkApiSurfaceAccumulator } from "../../domain/analysisView/WebNetworkApiSurfaceAccumulator.js";
+import { admitAnalysisViewData } from "../../domain/analysisView/analysisViewDataAdmission.js";
 /** Authenticate a selected-view request and project already completed Evidence. */
 export const inspectAnalysisView = (rawInput, lookup) => {
     const parsed = inspectAnalysisViewInputSchema.safeParse(rawInput);
@@ -15,8 +19,18 @@ export const inspectAnalysisView = (rawInput, lookup) => {
         return err(analysisInputErrorFromIssues(INSPECT_ANALYSIS_VIEW_OPERATION, parsed.error.issues, rawInput, { cause: parsed.error }));
     return inspectAnalysisViewValidated(parsed.data, lookup);
 };
-/** Project a view from input already parsed by a trusted adapter. */
+/** Authenticate borrowed inline Evidence after adapter envelope validation. */
 export const inspectAnalysisViewValidated = (input, lookup) => {
+    const accumulator = input.view.kind === "api-surface"
+        ? new WebNetworkApiSurfaceAccumulator(undefined, input.view.include_query_parameter_names === true)
+        : undefined;
+    if (input.source.kind === "inline") {
+        const admitted = accumulator === undefined
+            ? admitAnalysisViewData(input.source.evidence, true)
+            : accumulator.admitInlineEvidence(input.source.evidence);
+        if (!admitted.ok)
+            return admitted;
+    }
     const resolved = resolveAnalysisViewSource(input.source, lookup);
     if (!resolved.ok)
         return resolved;
@@ -25,14 +39,18 @@ export const inspectAnalysisViewValidated = (input, lookup) => {
         evidenceId: parent.evidence_id,
         operation: parent.operation,
         normalizedResult: parent.normalized_result,
+        // Sealing an Evidence root deep-freezes it; only the root is registered.
+        sealedResult: isImmutableJsonSnapshot(parent),
+        subject: parent.subject,
         limitations: parent.limitations,
+        parameters: parent.parameters,
         artifact: parent.subject === null
             ? null
             : {
                 path: parent.subject.local_path,
                 sha256: parent.subject.digest.sha256,
             },
-    }, input.view);
+    }, input.view, accumulator);
     if (!projected.ok)
         return projected;
     if (parent.subject !== null &&
@@ -40,24 +58,34 @@ export const inspectAnalysisViewValidated = (input, lookup) => {
         return err(new EvidenceIntegrityError(`Parent subject SHA-256 ${parent.subject.digest.sha256} differs from analysis artifact SHA-256 ${projected.value.artifact.sha256}.`));
     return ok(createAnalysisViewEvidence(input, parent, projected.value));
 };
+/** Fail before analysis when selected delivery cannot keep its complete source. */
+export const requireAnalysisViewRetention = (operation, retention) => {
+    if (retention.recordEvidence === undefined ||
+        retention.evidenceById === undefined)
+        return err(new AnalysisCapabilityUnavailableError(ANALYSIS_VIEW_PROVIDER.id, operation, "summary detail requires a server session that retains Evidence for later views", {
+            userMessage: "This server does not retain Evidence. Select detail complete to receive the complete analysis inline.",
+        }));
+    return ok({
+        evidenceById: retention.evidenceById,
+        recordEvidence: retention.recordEvidence,
+    });
+};
 /**
  * Retain complete analysis Evidence in the session, then project its summary
  * view from the retained record. Callers page or select the rest through
  * inspect_analysis_view with the view's parent Evidence ID.
  */
 export const summarizeRetainedAnalysis = (evidence, retention) => {
-    if (retention.recordEvidence === undefined ||
-        retention.evidenceById === undefined)
-        return err(new AnalysisCapabilityUnavailableError(ANALYSIS_VIEW_PROVIDER.id, evidence.operation, "summary detail requires a server session that retains Evidence for later views", {
-            userMessage: "This server does not retain Evidence. Select detail complete to receive the complete analysis inline.",
-        }));
-    const recorded = retention.recordEvidence(evidence);
+    const ready = requireAnalysisViewRetention(evidence.operation, retention);
+    if (!ready.ok)
+        return ready;
+    const recorded = ready.value.recordEvidence(evidence);
     if (!recorded.ok)
         return recorded;
     return inspectAnalysisViewValidated({
         source: { kind: "retained-evidence", evidence_id: evidence.evidence_id },
         view: { kind: "summary" },
-    }, retention.evidenceById);
+    }, ready.value.evidenceById);
 };
 const resolveAnalysisViewSource = (source, lookup) => {
     if (source.kind === "retained-evidence")
@@ -96,9 +124,16 @@ const createAnalysisViewEvidence = (input, parent, result) => {
         },
         result: jsonValueSchema.parse(result),
         rawResult: null,
-        confidence: "derived",
+        confidence: 
+        // Paging follows the full grouping, so any templated group makes every page inferred.
+        result.kind === "api-surface" && result.templated_groups > 0
+            ? "inferred"
+            : "derived",
         authority: parent.authority,
         limitations: result.limitations,
+        ...(result.kind === "native" && parent.relationship_coverage !== null
+            ? { relationshipCoverage: parent.relationship_coverage }
+            : {}),
         locations: [
             ...(result.artifact.path.length > 0
                 ? [{ kind: "artifact-path", path: result.artifact.path }]