rea-agents 4.0.0 → 4.1.0

package/dist/application/JavaScriptApplicationService.js

@@ -1,11 +1,15 @@
 import { z } from "zod";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { AnalysisInputError, AnalysisProtocolError, ArtifactOperationError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../domain/artifactOperationError.js";
+import {} from "../domain/analysisErrorBase.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { err, ok } from "../domain/result.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { createJavaScriptApplicationEvidence } from "./JavaScriptApplicationEvidence.js";
 import { reconstructJavaScriptArtifact } from "./JavaScriptArtifactReconstruction.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER } from "./InvestigationProviders.js";
 const OPERATION = "analyze_javascript_application";
 /** Statically analyze one local JavaScript/Electron application. */
 export const analyzeJavaScriptApplication = async (rawInput, options = {}) => {
@@ -46,7 +50,50 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         if (cause instanceof ArtifactReaderFailure)
             return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details));
         if (cause instanceof z.ZodError)
-            return err(new AnalysisProtocolError("JavaScript application analysis produced an invalid result", { cause }));
-        return err(new ArtifactOperationError(OPERATION, "io"));
+            return err(new AnalysisOutputError(OPERATION, describeResultSchemaFailure(cause), {
+                cause,
+            }));
+        if (cause instanceof Error &&
+            "code" in cause &&
+            typeof cause.code === "string" &&
+            FILESYSTEM_ERROR_CODES.has(cause.code))
+            return err(new ArtifactOperationError(OPERATION, "io"));
+        return err(new ProviderAdapterError(JAVASCRIPT_APPLICATION_PROVIDER.id, OPERATION, {
+            cause,
+            diagnostics: {
+                input_path: input.input_path,
+                error_name: cause instanceof Error ? cause.name : "UnknownError",
+                error_message: cause instanceof Error
+                    ? cause.message
+                    : typeof cause === "string"
+                        ? cause
+                        : "JavaScript analysis failed with a non-Error value",
+            },
+        }));
     }
 };
+const describeResultSchemaFailure = (cause) => {
+    const issue = cause.issues[0];
+    if (issue === undefined)
+        return "Result schema rejected an unknown issue";
+    const path = issue.path.flatMap((part) => typeof part === "string" || typeof part === "number" ? [part] : []);
+    const pointer = path.length === 0
+        ? "/"
+        : `/${path.map((part) => escapePointerPart(String(part))).join("/")}`;
+    return `Result schema rejected ${String(cause.issues.length)} ${cause.issues.length === 1 ? "issue" : "issues"} at ${pointer} (${issue.code})`;
+};
+const escapePointerPart = (part) => part.replaceAll("~", "~0").replaceAll("/", "~1");
+const FILESYSTEM_ERROR_CODES = new Set([
+    "ENOENT",
+    "EACCES",
+    "EPERM",
+    "ENOTDIR",
+    "EISDIR",
+    "EIO",
+    "ELOOP",
+    "ENAMETOOLONG",
+    "EMFILE",
+    "ENFILE",
+    "ENOSPC",
+    "EROFS",
+]);

package/dist/application/JavaScriptApplicationWorkflowService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { compareJavaScriptApplicationVersions } from "../domain/javascriptApplicationVersionComparison.js";
 import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";

package/dist/application/JavaScriptArtifactAnalysis.js

@@ -102,7 +102,8 @@ const parsePackage = (file) => {
     try {
         value = JSON.parse(file.text.value);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return invalidPackage(file, "package.json is not valid JSON.");
     }
     if (!isRecord(value))
@@ -163,7 +164,8 @@ const parseSourceMap = (file) => {
     try {
         value = JSON.parse(file.text.value);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return invalidSourceMap(file, "Source map is not valid JSON.");
     }
     const maps = flattenSourceMaps(value);

package/dist/application/JavaScriptArtifactFiles.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
 import { ArtifactPathRegistry, normalizeArtifactPath, } from "../artifacts/ArtifactPaths.js";
 import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
@@ -117,7 +118,9 @@ const readText = async (context, input) => {
             value: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
         };
     }
-    catch {
+    catch (cause) {
+        // Non-UTF8 bytes are counted; the fixed reason preserves the schema.
+        void cause;
         context.invalidUtf8 += 1;
         return { included: false, reason: "invalid-utf8" };
     }
@@ -197,4 +200,3 @@ const abortIfNeeded = (signal) => {
     if (signal?.aborted === true)
         throw new ArtifactReaderFailure("cancelled", "JavaScript artifact reconstruction cancelled");
 };
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/JavaScriptArtifactPathResolution.js

@@ -296,7 +296,9 @@ const packageEntry = (text, moduleKind, useExports) => {
         const legacy = packagePathValue(entry);
         return legacy.status === "value" ? { ...legacy, source: "legacy" } : legacy;
     }
-    catch {
+    catch (cause) {
+        // Reflect-based manifest reads fail closed as invalid.
+        void cause;
         return { status: "invalid" };
     }
 };
@@ -390,7 +392,9 @@ const fileUrlPath = (value) => {
             return undefined;
         return decodeURIComponent(url.pathname).replace(/^\/+/, "");
     }
-    catch {
+    catch (cause) {
+        // Unparseable file URLs have no path to resolve.
+        void cause;
         return undefined;
     }
 };

package/dist/application/JavaScriptJsonModules.js

@@ -1,3 +1,4 @@
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 /** Parse one approved JSON module without evaluating JavaScript or resolving imports. */
 export const analyzeJavaScriptJsonModule = (file) => {
     if (!file.text.included)
@@ -13,7 +14,8 @@ export const analyzeJavaScriptJsonModule = (file) => {
     try {
         value = JSON.parse(file.text.value);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return {
             path: file.path,
             sha256: file.sha256,
@@ -36,4 +38,3 @@ export const analyzeJavaScriptJsonModule = (file) => {
         limitation: null,
     };
 };
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/JavaScriptModuleRelationships.js

@@ -1,4 +1,5 @@
 import { posix } from "node:path";
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
 import { addAstContainsEdge, artifactLocalIdentity, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
@@ -271,11 +272,12 @@ const jsonStatus = (file) => {
         JSON.parse(file.text.value);
         return "included";
     }
-    catch {
+    catch (cause) {
+        // Invalid JSON is classified without further detail.
+        void cause;
         return "invalid";
     }
 };
 const isExportLink = (link) => link.kind === "export" ||
     link.kind === "re-export" ||
     link.kind === "commonjs-export";
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/JavaScriptRuntimeObservationService.js

@@ -1,5 +1,6 @@
 import { createJavaScriptRuntimeObservationEvidence } from "./JavaScriptRuntimeObservationEvidence.js";
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 /** List targets exposed by the explicitly selected loopback Inspector. */
 export const listJavaScriptRuntimeTargets = async (provider, input, options = {}) => {

package/dist/application/JavaScriptRuntimeReconciliationService.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { reconcileJavaScriptRuntime } from "../domain/javascriptRuntimeReconciliation.js";
 import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";

package/dist/application/JavaScriptSemanticGraphProjection.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../domain/javascriptApplicationGraph.js";
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES } from "../domain/javascriptSemanticGraphSchemas.js";
 /** Find the innermost callable that contains one exact source range. */
 export const owningSemanticCallableNode = (location, ir, nodes) => {

package/dist/application/JavaScriptSemanticTraceService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { queryJavaScriptSemanticGraph } from "../domain/javascriptSemanticQuery.js";
 import { javaScriptSemanticTraceResultSchema, traceJavaScriptSemanticsInputSchema, } from "../domain/javascriptSemanticTraceSchemas.js";

package/dist/application/JsonFiles.js

@@ -1,7 +1,7 @@
 import { link, lstat, mkdtemp, readFile, realpath, rm } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 import writeFileAtomic from "write-file-atomic";
-import { EvidenceFileError } from "../domain/errors.js";
+import { EvidenceFileError } from "../domain/evidenceErrors.js";
 import { err, ok } from "../domain/result.js";
 /** Read JSON data from a regular file at the caller-supplied path. */
 export const readJsonFile = async (path) => {

package/dist/application/LazyAnalysisProvider.js

@@ -1,4 +1,6 @@
-import { AnalysisCancelledError, AnalysisError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err } from "../domain/result.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 const isAborted = (signal) => signal?.aborted === true;

package/dist/application/LinuxHopper.js

@@ -73,7 +73,9 @@ export const readLinuxDistribution = async () => {
     try {
         return parseLinuxDistribution(await readFile("/etc/os-release", "utf8"));
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional host probing; unknown distribution means unsupported.
+        void cause;
         return undefined;
     }
 };
@@ -143,7 +145,9 @@ const systemLinuxHopperInstallHost = () => ({
                 ? "ready"
                 : "unsupported_hopper_build";
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: optional launcher probing; unreadable means missing.
+            void cause;
             return "missing";
         }
     },
@@ -157,7 +161,9 @@ export const linuxHopperBinarySupported = async (path) => {
             hash.update(chunk);
         return hash.digest("hex") === SUPPORTED_HOPPER_SHA256;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional build probing; unreadable means unsupported.
+        void cause;
         return false;
     }
 };
@@ -169,7 +175,9 @@ const installSystemPackage = async (family, archive) => {
             await execFileAsync(command.executable, command.args);
         return true;
     }
-    catch {
+    catch (cause) {
+        // Package-manager failure is reported by the false return.
+        void cause;
         return false;
     }
 };

package/dist/application/MacHopper.js

@@ -63,7 +63,9 @@ export const installMacHopper = async (options = {}, host = systemMacHopperInsta
         await host.openApplication(destination);
         return { status: "installed", launcherPath };
     }
-    catch {
+    catch (cause) {
+        // Install-stage failures share the download reason; the stage is cleaned below.
+        void cause;
         return { status: "failed", reason: "download" };
     }
     finally {
@@ -114,7 +116,9 @@ const systemMacHopperInstallHost = () => ({
             ])).stdout.trim();
             return identifier === BUNDLE_IDENTIFIER;
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: optional bundle probing; unreadable means invalid.
+            void cause;
             return false;
         }
     },
@@ -123,7 +127,9 @@ const systemMacHopperInstallHost = () => ({
             await access(path);
             return true;
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: optional existence probing; absence means missing.
+            void cause;
             return false;
         }
     },
@@ -142,14 +148,17 @@ const systemMacHopperInstallHost = () => ({
                 await rm(previous, { recursive: true, force: true });
             return true;
         }
-        catch {
+        catch (cause) {
+            // Install failure rolls back below; the false return reports it.
+            void cause;
             await rm(stage, { recursive: true, force: true });
             if (replaceExisting) {
                 try {
                     await rename(previous, destination);
                 }
-                catch {
+                catch (rollbackCause) {
                     // The original destination was not moved, or rollback is impossible.
+                    void rollbackCause;
                 }
             }
             return false;
@@ -160,7 +169,9 @@ const systemMacHopperInstallHost = () => ({
             await access(path);
             return true;
         }
-        catch {
+        catch (cause) {
+            // best-effort cleanup: optional launcher probing; absence means not ready.
+            void cause;
             return false;
         }
     },
@@ -190,7 +201,9 @@ const commandSucceeds = async (command, args) => {
         await execFileAsync(command, args);
         return true;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional command probing; failure means unavailable.
+        void cause;
         return false;
     }
 };

package/dist/application/ManagedApplicationGraphService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../domain/managedApplicationGraph.js";

package/dist/application/ManagedMemberComparisonService.js

@@ -2,7 +2,9 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../domain/managedMemberComparison.js";
-import { AnalysisInputError, AnalysisProtocolError, EvidenceIntegrityError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";

package/dist/application/ManagedNativeVerificationService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../domain/managedNativeVerification.js";

package/dist/application/ManagedReconstructionService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../domain/managedReconstruction.js";

package/dist/application/NativeCallRoutes.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { parseRelatedAddresses, referenceKindSchema, } from "../domain/hopperValues.js";
 import { err, ok } from "../domain/result.js";
-import { AnalysisOutputError } from "../domain/errors.js";
+import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
 const referencesSchema = z.object({
     reference_kinds_available: z.boolean().optional(),
     references: z.array(z.object({

package/dist/application/NativeDispatchMetadataInspection.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { nativeDispatchMetadataResultSchema, inspectNativeDispatchMetadata, } from "../domain/objcSwiftMetadata.js";
-import { AnalysisOutputError } from "../domain/errors.js";
+import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
 /** Prefer validated binary metadata, otherwise preserve the bound provider's symbol-only coverage. */

package/dist/application/NativeUiActionTrace.js

@@ -6,7 +6,8 @@ import { inspectNativeDispatch } from "./NativeDispatchMetadataInspection.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { readNativeCallRoutes } from "./NativeCallRoutes.js";
 import { err, ok } from "../domain/result.js";
-import { AnalysisOutputError, projectAnalysisError } from "../domain/errors.js";
+import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 /** Build a UI-to-code trace from the active app and selected native provider. */
 export const traceNativeUiAction = async (analysis, input, signal) => {
     const [uiExecution, metadataExecution] = await Promise.all([

package/dist/application/NativeValueTrace.js

@@ -2,7 +2,7 @@ import { functionDossierSchema } from "../domain/hopperValues.js";
 import { nativeCallTargetsSchema } from "../domain/nativeInstruction.js";
 import { nativeValueTraceInputSchema, nativeValueTraceSchema, } from "../domain/nativeValueTrace.js";
 import { createEvidence } from "../domain/evidence.js";
-import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
 /** Compose bounded high-p-code def-use graphs across exactly referenced call destinations. */
 export const traceNativeValues = async (analysis, parameters, signal) => {

package/dist/application/ProcessCaptureError.js

@@ -1,4 +1,4 @@
-import { AnalysisError } from "../domain/errors.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 /** Typed application failure produced by controlled process capture. */
 export class ProcessCaptureError extends AnalysisError {
     _tag = "ProcessCaptureError";

package/dist/application/ProcessCaptureJournal.js

@@ -33,7 +33,9 @@ export const scheduleScenarioInteractions = (options) => {
                     else
                         terminal.kill(event.signal);
                 }
-                catch {
+                catch (cause) {
+                    // Terminal dispatch failures are recorded as failed outcomes.
+                    void cause;
                     outcome = "failed";
                 }
             }

package/dist/application/ProcessCaptureLifecycle.js

@@ -7,7 +7,8 @@ import { digestProcessCommitment, processComparisonContract, processScenarioComm
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { snapshotRoots } from "./FilesystemSnapshot.js";
 import { classifyFilesystemEffects } from "./ProcessFilesystemEffects.js";
-import { cleanupOwnedProcessGroup, observeOwnedProcessGroup, } from "../process/ProcessOwnership.js";
+import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
+import { observeOwnedProcessGroup } from "../process/ProcessOwnershipObservation.js";
 import { ProcessCaptureError } from "./ProcessCaptureError.js";
 import { assertNotCancelled } from "./ProcessScenarioRuntimeValidation.js";
 import { normalizeProcessElapsedTime, normalizeProcessSamples, normalizeProcessText, } from "./ProcessNormalization.js";
@@ -216,7 +217,8 @@ export const releaseProcessResources = async (options) => {
     try {
         await options.renderer?.dispose();
     }
-    catch {
+    catch (cause) {
+        void cause;
         failure ??= "terminal renderer cleanup failed";
     }
     if (options.terminal !== undefined && host.platform !== "win32") {
@@ -233,7 +235,8 @@ export const releaseProcessResources = async (options) => {
     try {
         await host.removeTemporaryRoot(options.temporaryRoot);
     }
-    catch {
+    catch (cause) {
+        void cause;
         failure ??= "temporary process root cleanup failed";
     }
     return failure;

package/dist/application/ProcessCli.js

@@ -1,5 +1,7 @@
 import { readFile } from "node:fs/promises";
-import { AnalysisError, AnalysisInputError, projectAnalysisError, } from "../domain/errors.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
@@ -75,7 +77,7 @@ const parseCaptureEvidence = (input) => {
     try {
         evidence = parseEvidence(input);
     }
-    catch {
+    catch (cause) {
         throw invalidCaptureEvidence();
     }
     if (evidence.operation !== "capture_process_scenario" ||
@@ -91,7 +93,7 @@ const parseCaptureEvidence = (input) => {
             locations: evidence.locations,
         };
     }
-    catch {
+    catch (cause) {
         throw invalidCaptureEvidence();
     }
 };
@@ -107,14 +109,16 @@ const readJson = async (path) => {
     try {
         bytes = await readFile(path);
     }
-    catch {
+    catch (cause) {
+        void cause;
         throw new ProcessCliFailure("invalid_input", "Process input file could not be read. Check that the path exists and is readable.");
     }
     try {
         const parsed = JSON.parse(bytes.toString("utf8"));
         return parsed;
     }
-    catch {
+    catch (cause) {
+        void cause;
         throw new ProcessCliFailure("invalid_input", "Process input file is not valid JSON. Repair the file, then try again.");
     }
 };

package/dist/application/ProcessEvidence.js

@@ -1,11 +1,7 @@
 import { createEvidence } from "../domain/evidence.js";
+import { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-/** Provider identity for controlled process capture evidence. */
-export const PROCESS_PROVIDER = {
-    id: "rea-process",
-    name: "REA process capture",
-    version: "3",
-};
+export { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
 /** Project one process scenario into secret-free Evidence parameters. */
 const processEvidenceParameters = (scenario) => ({
     executable_name: scenario.executable.split("/").at(-1) ?? scenario.executable,

package/dist/application/ProcessHarness.js

@@ -1,13 +1,14 @@
 import { parseProcessCapture } from "../domain/processCapture.js";
 import { err, ok } from "../domain/result.js";
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
 export { ProcessCaptureError } from "./ProcessCaptureError.js";
 import { startProcessSampler } from "./ProcessSampling.js";
 import { snapshotRoots } from "./FilesystemSnapshot.js";
 import { TerminalRenderer } from "./TerminalRenderer.js";
 import { normalizeProcessText } from "./ProcessNormalization.js";
-import { selectCapturedProcessGroupIds } from "../process/ProcessOwnership.js";
+import { selectCapturedProcessGroupIds } from "../process/ProcessOwnershipProcessTree.js";
 import { awaitTerminalExit, buildCaptureResult, captureTerminalFrames, createRunManifest, observeSettlement, prepareProcessCapture, releaseProcessResources, resolveProcessResult, settleProcessCaptureJournal, } from "./ProcessCaptureLifecycle.js";
 import { assertNotCancelled, resolveProcessScenarioRuntimePaths, } from "./ProcessScenarioRuntimeValidation.js";
 import { createProcessCaptureJournal, scheduleScenarioInteractions, } from "./ProcessCaptureJournal.js";

package/dist/application/ProcessNormalization.js

@@ -18,6 +18,7 @@ export const normalizeProcessText = (value, scenario, temporaryRoot, pid) => {
         normalized = normalized.replaceAll(pattern.pattern, pattern.replacement);
     return normalized;
 };
+/** Project sampled observations under the caller-selected normalization rules. */
 export const normalizeProcessSamples = (samples, scenario, rootPid) => {
     const identifiers = [
         rootPid,
@@ -41,12 +42,18 @@ export const normalizeProcessSamples = (samples, scenario, rootPid) => {
     };
     return samples.map((sample) => ({
         at_ms: normalizeProcessElapsedTime(sample.at_ms, scenario.normalization.time_bucket_ms),
-        pid: mapping.get(sample.pid) ?? 1,
-        parent_pid: mapping.get(sample.parent_pid) ?? 0,
-        process_group_id: sample.process_group_id === null
-            ? null
+        pid: scenario.normalization.pids
+            ? (mapping.get(sample.pid) ?? 1)
+            : sample.pid,
+        parent_pid: scenario.normalization.pids
+            ? (mapping.get(sample.parent_pid) ?? 0)
+            : sample.parent_pid,
+        process_group_id: !scenario.normalization.pids || sample.process_group_id === null
+            ? sample.process_group_id
             : (mapping.get(sample.process_group_id) ?? 0),
-        session_id: sample.session_id === null ? null : (mapping.get(sample.session_id) ?? 0),
+        session_id: !scenario.normalization.pids || sample.session_id === null
+            ? sample.session_id
+            : (mapping.get(sample.session_id) ?? 0),
         command: normalizeCommand(sample.command),
     }));
 };

package/dist/application/ProcessSampling.js

@@ -240,7 +240,9 @@ const inspectInitializedPtyRoot = async (rootPid, runId, signal) => {
     try {
         observedRunId = await readProcessRunId(rootPid);
     }
-    catch {
+    catch (cause) {
+        // Unreadable run identity means the root cannot be attributed.
+        void cause;
         return undefined;
     }
     const after = await readRootIdentity(rootPid, signal);

package/dist/application/ReconstructionCoverageService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError } from "../domain/errors.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { evaluateReconstructionClosure, reconstructionCoverageDataSchema, } from "../domain/reconstructionCoverage.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";

package/dist/application/ReconstructionObligationLedgerService.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";