rea-agents 6.3.0 → 6.5.0

package/dist/application/WebScriptExportService.js

@@ -6,26 +6,28 @@ import { publishWebScripts } from "../browser/assets/PublishWebScripts.js";
 import { selectScriptCapture } from "../browser/assets/ScriptCaptureAdapters.js";
 import { AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { createEvidence } from "../domain/evidence.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
 import { safeParseJson } from "../domain/safeJson.js";
 import { exportWebScriptsInputSchema, } from "../domain/webScriptExport.js";
 import { WebScriptExportError } from "../domain/webScriptExportError.js";
 import { WEB_SCRIPT_EXPORT_PROVIDER as PROVIDER } from "./InvestigationProviders.js";
-import { readRegularFile } from "./RegularFileRead.js";
-import { NonRegularFileReadError } from "../filesystem/RegularFile.js";
+import { readRegularFile, RegularFileCleanupFailure, retryRegularFileCleanup, } from "./RegularFileRead.js";
+import { NonRegularFileReadError, RegularFileChangedError, } from "../filesystem/RegularFile.js";
 const OPERATION = "export_web_scripts";
 /** Export one local capture through the shared CLI/MCP application workflow. */
-export const exportWebScripts = async (rawInput, options = {}) => {
+export const exportWebScripts = async (rawInput, resources, options = {}) => {
     const input = exportWebScriptsInputSchema.safeParse(rawInput);
     return input.success
-        ? exportWebScriptsValidated(input.data, options)
+        ? exportWebScriptsValidated(input.data, resources, options)
         : err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput));
 };
 /** Publish input already parsed by a named adapter contract. */
-export const exportWebScriptsValidated = async (input, options = {}) => {
+export const exportWebScriptsValidated = async (input, resources, options = {}) => {
     if (!isAbsolute(input.capture_path) || !isAbsolute(input.output_directory))
         return err(new AnalysisInputError(OPERATION, undefined, [
             {
@@ -36,16 +38,16 @@ export const exportWebScriptsValidated = async (input, options = {}) => {
         ]));
     try {
         options.signal?.throwIfAborted();
-        const read = await readCapture(input.capture_path, options.signal);
-        if (!read.ok)
-            return read;
-        const bytes = read.value;
-        const loaded = parseCapture(bytes);
-        if (!loaded.ok)
-            return loaded;
+        const prepared = await prepareCapture(input.capture_path, resources, options.signal);
+        if (!prepared.ok)
+            return prepared;
+        const { bytes, loaded } = prepared.value;
         options.signal?.throwIfAborted();
         const sha256 = createHash("sha256").update(bytes).digest("hex");
-        const result = await publishWebScripts(input, loaded.value, sha256, options.signal);
+        const result = await publishWebScripts(input, loaded, sha256, {
+            resources,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
         return ok(createEvidence({ path: input.capture_path, sha256, format: "file" }, PROVIDER, {
             predicateType: "rea.web-script-export",
             operation: OPERATION,
@@ -59,71 +61,132 @@ export const exportWebScriptsValidated = async (input, options = {}) => {
             authority: "historical-reference",
             limitations: result.limitations,
             locations: [{ kind: "artifact-path", path: result.manifest.path }],
-            evidenceLinks: loaded.value.sourceEvidenceId === null
-                ? []
-                : [loaded.value.sourceEvidenceId],
+            evidenceLinks: loaded.sourceEvidenceId === null ? [] : [loaded.sourceEvidenceId],
         }));
     }
     catch (cause) {
-        if (cause instanceof WebScriptExportError)
-            return err(cause);
-        if (options.signal?.aborted === true)
-            return err(new AnalysisCancelledError(OPERATION));
-        if (cause instanceof ArtifactReaderFailure)
-            return err(new WebScriptExportError(cause.reason, input.output_directory, cause.message));
-        if (cause instanceof z.ZodError)
-            return err(new AnalysisOutputError(OPERATION, cause.message, { cause }));
-        if (cause instanceof Error &&
-            "code" in cause &&
-            typeof cause.code === "string")
-            return err(new WebScriptExportError("io", `${input.capture_path} → ${input.output_directory}`, cause.message));
-        return err(new ProviderAdapterError(PROVIDER.id, OPERATION, {
-            cause,
-            diagnostics: {
-                capture_path: input.capture_path,
-                output_directory: input.output_directory,
-                error_name: cause instanceof Error ? cause.name : "UnknownError",
-                error_message: cause instanceof Error
-                    ? cause.message
-                    : typeof cause === "string"
-                        ? cause
-                        : "Unknown script export failure",
-            },
-        }));
+        return err(mapExportFailure(cause, input, options.signal));
+    }
+};
+const prepareCapture = async (path, resources, signal) => {
+    const read = await resources.run(() => readCapture(path, resources, signal));
+    if (!read.ok)
+        return read;
+    const cleanup = read.value.cleanup;
+    const loaded = parseCapture(read.value.bytes, cleanup === undefined || cleanup.incomplete
+        ? undefined
+        : { cause: cleanup.cause });
+    if (!loaded.ok)
+        return err(cleanup?.incomplete === true
+            ? incompleteCaptureCleanup(loaded.error, path, cleanup)
+            : loaded.error);
+    if (cleanup !== undefined) {
+        const primary = new WebScriptExportError("io", path, `Capture handle close failed: ${cleanup.reason}`, { cause: cleanup.cause });
+        return err(cleanup.incomplete
+            ? incompleteCaptureCleanup(primary, path, cleanup)
+            : primary);
     }
+    return ok({ bytes: read.value.bytes, loaded: loaded.value });
+};
+const mapExportFailure = (cause, input, signal) => {
+    if (cause instanceof WebScriptExportError)
+        return cause;
+    if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined)
+        return analysisErrorWithCleanupFailure(new WebScriptExportError(cause.reason, input.output_directory, cause.message, { cause }), new ProviderCleanupError(PROVIDER.id, cause.cleanup.resources, { reason: cause.cleanup.reason }, { cause, operation: OPERATION }), OPERATION);
+    if (signal?.aborted === true)
+        return new AnalysisCancelledError(OPERATION, { cause });
+    if (cause instanceof ArtifactReaderFailure)
+        return new WebScriptExportError(cause.reason, input.output_directory, cause.message, { cause });
+    if (cause instanceof z.ZodError)
+        return new AnalysisOutputError(OPERATION, cause.message, { cause });
+    if (cause instanceof Error &&
+        "code" in cause &&
+        typeof cause.code === "string")
+        return new WebScriptExportError("io", `${input.capture_path} → ${input.output_directory}`, cause.message, { cause });
+    return new ProviderAdapterError(PROVIDER.id, OPERATION, {
+        cause,
+        diagnostics: {
+            capture_path: input.capture_path,
+            output_directory: input.output_directory,
+            error_name: cause instanceof Error ? cause.name : "UnknownError",
+            error_message: cause instanceof Error
+                ? cause.message
+                : typeof cause === "string"
+                    ? cause
+                    : "Unknown script export failure",
+        },
+    });
 };
 /**
  * Read the caller-selected capture. A missing, non-file or unreadable
  * selection is a caller or host-permission failure, not an export failure.
  */
-const readCapture = async (path, signal) => {
+const readCapture = async (path, resources, signal) => {
     try {
-        return ok(await readRegularFile(path, signal));
+        return ok({ bytes: await readRegularFile(path, { signal }) });
     }
     catch (cause) {
-        const code = cause instanceof Error && "code" in cause ? String(cause.code) : "";
-        if (code === "EACCES" || code === "EPERM")
-            return err(new AnalysisAccessDeniedError(OPERATION, path, code, { cause }));
-        if (cause instanceof NonRegularFileReadError ||
-            code === "ENOENT" ||
-            code === "ENOTDIR" ||
-            code === "EISDIR" ||
-            code === "ENXIO")
-            return err(new AnalysisInputError(OPERATION, { cause }, [
-                {
-                    path: ["capture_path"],
-                    reason: "invalid_value",
-                    message: cause instanceof NonRegularFileReadError && code !== "EISDIR"
-                        ? cause.message
-                        : code === "EISDIR"
-                            ? `Selected capture is a directory, not a file: ${path}`
-                            : `Selected capture could not be read (${code}): ${path}`,
-                },
-            ]));
-        throw cause;
+        if (cause instanceof RegularFileCleanupFailure) {
+            const retry = await retryRegularFileCleanup(cause, resources);
+            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);
+            return err(retry.cleanup === undefined
+                ? primary
+                : incompleteCaptureCleanup(primary, path, cleanup));
+        }
+        return err(captureReadFailure(path, cause, signal));
     }
 };
-const parseCapture = (bytes) => {
+const captureReadFailure = (path, cause, signal, closeFailure) => {
+    const causeWithClose = closeFailure === undefined
+        ? cause
+        : new AggregateError([cause, closeFailure.cause], "Capture read and file-handle close both failed", { cause });
+    if (signal?.aborted === true)
+        return new AnalysisCancelledError(OPERATION, { cause: causeWithClose });
+    const code = cause instanceof Error && "code" in cause ? String(cause.code) : "";
+    if (code === "EACCES" || code === "EPERM")
+        return new AnalysisAccessDeniedError(OPERATION, path, code, {
+            cause: causeWithClose,
+        });
+    if (cause instanceof NonRegularFileReadError ||
+        cause instanceof RegularFileChangedError ||
+        code === "ENOENT" ||
+        code === "ENOTDIR" ||
+        code === "EISDIR" ||
+        code === "ENXIO")
+        return new AnalysisInputError(OPERATION, { cause: causeWithClose }, [
+            {
+                path: ["capture_path"],
+                reason: "invalid_value",
+                message: cause instanceof NonRegularFileReadError && code !== "EISDIR"
+                    ? cause.message
+                    : code === "EISDIR"
+                        ? `Selected capture is a directory, not a file: ${path}`
+                        : `Selected capture could not be read (${code}): ${path}`,
+            },
+        ]);
+    if (code !== "")
+        return new WebScriptExportError("io", path, errorMessage(cause), {
+            cause: causeWithClose,
+        });
+    return new ProviderAdapterError(PROVIDER.id, OPERATION, {
+        cause: causeWithClose,
+        diagnostics: {
+            capture_path: path,
+            error_name: cause instanceof Error ? cause.name : "UnknownError",
+            error_message: cause instanceof Error ? cause.message : String(cause),
+        },
+    });
+};
+const incompleteCaptureCleanup = (primary, path, cleanup) => analysisErrorWithCleanupFailure(primary, new ProviderCleanupError(PROVIDER.id, [path], { reason: cleanup.reason }, { cause: cleanup.cause, operation: OPERATION }), OPERATION);
+const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+const parseCapture = (bytes, closeFailure) => {
     try {
         const text = new TextDecoder("utf-8", {
             fatal: true,
@@ -135,7 +198,10 @@ const parseCapture = (bytes) => {
         return ok(selectScriptCapture(json.value));
     }
     catch (cause) {
-        return err(new AnalysisInputError(OPERATION, { cause }, [
+        const causeWithClose = closeFailure === undefined
+            ? cause
+            : new AggregateError([cause, closeFailure.cause], "Capture parse and file-handle close both failed", { cause });
+        return err(new AnalysisInputError(OPERATION, { cause: causeWithClose }, [
             {
                 path: ["capture_path"],
                 reason: "invalid_format",

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";
@@ -25,8 +26,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;
@@ -35,6 +44,12 @@ export class WebSourceLocationService {
         this.artifacts = artifacts;
         this.decoder = decoder;
     }
+    close() {
+        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) {
         if (options?.signal?.aborted)
@@ -78,6 +93,10 @@ export class WebSourceLocationService {
             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),
@@ -90,7 +109,7 @@ export class WebSourceLocationService {
             generated_offset: generatedOffset,
             source_authenticity: "unknown",
             execution: "unknown",
-            limitations: LIMITATIONS,
+            limitations,
         });
         if (!normalized.success)
             return invalidOutput(normalized.error.message);
@@ -109,7 +128,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,

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,27 @@
 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 { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+/** Retain the limits of exactly the observations used by one composed call. */
+export const executeComposedWorkflow = async (analysis, execute) => {
+    const limitations = new Set();
+    const result = await execute({
+        execute: async (operation, parameters, options) => {
+            const execution = await analysis.execute(operation, parameters, options);
+            if (execution.ok)
+                execution.value.limitations.forEach((limitation) => limitations.add(limitation));
+            return execution;
+        },
+    });
+    if (!result.ok)
+        return result;
+    return ok({
+        result: result.value,
+        limitations: [...limitations].sort(compareUnicodeCodePoints),
+    });
+};
 /** 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 +33,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/adb/AdbDeviceAnalysisPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/adb/AdbDeviceAnalysisService.js

@@ -0,0 +1,13 @@
+import { adbRequestSchema, } from "../../domain/adb/adbDeviceAnalysis.js";
+import { executeProviderOperation } from "../ProviderOperationExecution.js";
+/** Shared CLI/MCP admission, execution, and Evidence composition for ADB. */
+export class AdbDeviceAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Run one caller-selected ADB request and retain device provenance inline. */
+    async execute(operation, input, options) {
+        return executeProviderOperation(operation, input, options, adbRequestSchema, this.provider, "observed");
+    }
+}

package/dist/application/analysisView/AnalysisViewService.js

@@ -1,12 +1,16 @@
+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";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
 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";
 /** Authenticate a selected-view request and project already completed Evidence. */
 export const inspectAnalysisView = (rawInput, lookup) => {
     const parsed = inspectAnalysisViewInputSchema.safeParse(rawInput);
@@ -14,8 +18,16 @@ 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" && accumulator !== undefined) {
+        const admitted = accumulator.admitInlineEvidence(input.source.evidence);
+        if (!admitted.ok)
+            return admitted;
+    }
     const resolved = resolveAnalysisViewSource(input.source, lookup);
     if (!resolved.ok)
         return resolved;
@@ -24,8 +36,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,
-    }, input.view);
+        parameters: parent.parameters,
+        artifact: parent.subject === null
+            ? null
+            : {
+                path: parent.subject.local_path,
+                sha256: parent.subject.digest.sha256,
+            },
+    }, input.view, accumulator);
     if (!projected.ok)
         return projected;
     if (parent.subject !== null &&
@@ -33,20 +55,101 @@ 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) => {
+    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" },
+    }, ready.value.evidenceById);
+};
 const resolveAnalysisViewSource = (source, lookup) => {
     if (source.kind === "retained-evidence")
         return resolveEvidenceInput(source, lookup);
+    const invalidDataPath = inlineEvidenceInvalidDataPath(source.evidence);
+    if (invalidDataPath !== undefined)
+        return err(new AnalysisInputError(INSPECT_ANALYSIS_VIEW_OPERATION, undefined, [
+            {
+                path: ["source", "evidence", ...invalidDataPath],
+                reason: "invalid_type",
+                message: "Inline Evidence must contain plain JSON data properties without accessors or cycles.",
+            },
+        ]));
     try {
         return ok(parseEvidence(source.evidence));
     }
     catch (cause) {
         if (cause instanceof z.ZodError)
-            return err(analysisInputErrorFromIssues(INSPECT_ANALYSIS_VIEW_OPERATION, cause.issues, source.evidence, { cause }));
+            return err(analysisInputErrorFromIssues(INSPECT_ANALYSIS_VIEW_OPERATION, cause.issues.map((issue) => ({
+                ...issue,
+                path: ["source", "evidence", ...issue.path],
+            })), { source }, { cause }));
         if (cause instanceof TypeError)
             return err(new EvidenceIntegrityError(cause.message, cause.message.length > 0 ? { userMessage: cause.message } : undefined));
         throw cause;
     }
 };
+/** Reject non-JSON object behavior before Zod reads caller-owned Evidence. */
+const inlineEvidenceInvalidDataPath = (root) => {
+    const active = new Set();
+    const pending = [{ value: root, path: [] }];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            continue;
+        if (current.exit !== undefined) {
+            active.delete(current.exit);
+            continue;
+        }
+        const { value, path } = current;
+        if (typeof value !== "object" || value === null)
+            continue;
+        const isArray = Array.isArray(value);
+        const prototype = Object.getPrototypeOf(value);
+        if ((isArray && prototype !== Array.prototype) ||
+            (!isArray && prototype !== Object.prototype && prototype !== null) ||
+            active.has(value))
+            return path;
+        active.add(value);
+        pending.push({ value, path, exit: value });
+        const keys = Object.getOwnPropertyNames(value);
+        for (let index = keys.length - 1; index >= 0; index -= 1) {
+            const key = keys[index];
+            if (key === undefined)
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            const childPath = [
+                ...path,
+                isArray && /^(0|[1-9]\d*)$/u.test(key) ? Number(key) : key,
+            ];
+            if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
+                return childPath;
+            pending.push({ value: descriptor.value, path: childPath });
+        }
+    }
+    return undefined;
+};
 const createAnalysisViewEvidence = (input, parent, result) => {
     const target = parent.subject === null
         ? undefined
@@ -67,10 +170,23 @@ 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,
-        locations: [{ kind: "artifact-path", path: result.artifact.path }],
+        locations: [
+            ...(result.artifact.path.length > 0
+                ? [{ kind: "artifact-path", path: result.artifact.path }]
+                : []),
+            ...(result.kind === "native" &&
+                result.procedure_address !== null &&
+                result.procedure_address.length > 0
+                ? [{ kind: "address", address: result.procedure_address }]
+                : []),
+        ],
         evidenceLinks: [parent.evidence_id],
     });
 };

package/dist/application/android/AndroidPackageInspection.js

@@ -0,0 +1,25 @@
+import { requireAnalysisViewRetention, summarizeRetainedAnalysis, } from "../analysisView/AnalysisViewService.js";
+import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
+import { androidPackageInspectionInputSchema } from "../../domain/android/androidAnalysis.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err } from "../../domain/result.js";
+/** Preserve the complete provider request; select retained delivery explicitly. */
+export const inspectAndroidPackage = async (service, rawInput, retention, options) => {
+    const operation = "inspect_android_package";
+    if (options?.signal?.aborted === true)
+        return err(new AnalysisCancelledError(operation));
+    const parsed = androidPackageInspectionInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(analysisInputErrorFromIssues(operation, parsed.error.issues, rawInput, {
+            cause: parsed.error,
+        }));
+    if (parsed.data.detail === "summary") {
+        const ready = requireAnalysisViewRetention(operation, retention);
+        if (!ready.ok)
+            return ready;
+    }
+    const executed = await service.execute(operation, { path: parsed.data.path }, options);
+    if (!executed.ok || parsed.data.detail !== "summary")
+        return executed;
+    return summarizeRetainedAnalysis(executed.value, retention);
+};