rea-agents 6.1.0 → 6.3.0

package/dist/application/binary/CompositeProvider.js

@@ -1,8 +1,8 @@
 import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { err, ok } from "../../domain/result.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
-/** Synthetic compatibility identity for a deterministic provider set. */
-export const compositeProviderIdentity = (identities) => ({
+/** Synthetic identity for a deterministic provider set. */
+const compositeProviderIdentity = (identities) => ({
     id: `composite:${identities
         .map(({ id }) => id)
         .sort()
@@ -16,15 +16,10 @@ export class CompositeProvider {
     #identity;
     #capabilities;
     #providerByOperation;
-    #profileProvider;
     constructor(providers) {
         this.providers = providers;
         if (providers.length === 0)
             throw new RangeError("CompositeProvider requires at least one provider");
-        const profileProviders = providers.filter(({ resolveAnalysisProfile }) => resolveAnalysisProfile !== undefined);
-        if (profileProviders.length > 1)
-            throw new TypeError("CompositeProvider supports at most one target-bound analysis profile");
-        this.#profileProvider = profileProviders[0];
         this.#identity = Object.freeze(compositeProviderIdentity(providers.map((provider) => provider.identity())));
         const routes = new Map();
         const capabilities = [];
@@ -46,12 +41,6 @@ export class CompositeProvider {
     capabilities() {
         return this.#capabilities;
     }
-    resolveAnalysisProfile(target, options) {
-        const resolve = this.#profileProvider?.resolveAnalysisProfile;
-        return resolve === undefined
-            ? Promise.resolve(ok({ profile: null, compatibility: {} }))
-            : resolve.call(this.#profileProvider, target, options);
-    }
     createClient(target, profile, context) {
         const clients = new Map();
         const clientFor = (provider) => {
@@ -62,7 +51,7 @@ export class CompositeProvider {
             clients.set(provider, created);
             return created;
         };
-        const closeWithOutcome = async (options) => {
+        const close = async (options) => {
             const outcomes = await Promise.all([...clients.entries()].map(([provider, client]) => closeAnalysisClient(client, provider.identity().id, options)));
             return outcomes.find((outcome) => !outcome.ok) ?? ok(null);
         };
@@ -101,10 +90,7 @@ export class CompositeProvider {
                 }
                 return undefined;
             },
-            closeWithOutcome,
-            close: async () => {
-                await closeWithOutcome();
-            },
+            close,
         };
     }
 }

package/dist/application/binary/LazyAnalysisProvider.js

@@ -1,7 +1,7 @@
 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 { err, ok } from "../../domain/result.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 const isAborted = (signal) => signal?.aborted === true;
 /**
@@ -77,13 +77,13 @@ class LazyAnalysisClient {
     operationHealthSnapshot() {
         return this.#client?.operationHealthSnapshot?.();
     }
-    async close() {
+    close = async (options) => {
         this.#closed = true;
         if (this.#loading === undefined)
-            return;
+            return ok(null);
         const client = await this.#loading;
-        await client.close();
-    }
+        return client.close(options);
+    };
     async #load(operation) {
         if (this.#closed)
             throw new ProviderAdapterError(this.#providerId, operation, {

package/dist/application/binary/SessionProviderRouter.js

@@ -1,40 +1,18 @@
-import { analysisProfileSchema, } from "../../domain/analysisProfile.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
-import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { ProviderSelectionError } from "../../domain/providerSelectionError.js";
 import {} from "../../domain/analysisErrorBase.js";
-import { jsonObjectSchema } from "../../domain/jsonValue.js";
 import { err, ok } from "../../domain/result.js";
 import { AnalysisProviderRegistry, } from "./AnalysisProviderRegistry.js";
-import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
-import { CompositeProvider, compositeProviderIdentity, } from "./CompositeProvider.js";
-/** Resolve either the compatibility single-provider seam or a selectable set. */
+import { CompositeProvider } from "./CompositeProvider.js";
+/** Resolve one registry-selected deep provider and disjoint auxiliary families. */
 export class SessionProviderRouter {
-    runtime;
-    constructor(runtime) {
-        this.runtime = runtime;
-    }
-    /** Create routing for an embedding backed by one fixed provider or factory. */
-    static single(provider, options = {}) {
-        const identity = typeof provider === "function"
-            ? { id: "unidentified", name: "Unidentified provider", version: null }
-            : provider.identity();
-        const capabilities = typeof provider === "function"
-            ? undefined
-            : capabilityMap(provider.capabilities());
-        const resolveProfile = options.resolveAnalysisProfile ??
-            (typeof provider === "function" ||
-                provider.resolveAnalysisProfile === undefined
-                ? () => Promise.resolve(ok({ profile: null, compatibility: {} }))
-                : (target, resolutionOptions) => provider.resolveAnalysisProfile?.(target, resolutionOptions) ??
-                    Promise.resolve(ok({ profile: null, compatibility: {} })));
-        return new SessionProviderRouter({
-            kind: "single",
-            provider,
-            identity,
-            capabilities,
-            resolveProfile,
-        });
+    registry;
+    auxiliaryProviders;
+    route;
+    constructor(registry, auxiliaryProviders, route) {
+        this.registry = registry;
+        this.auxiliaryProviders = auxiliaryProviders;
+        this.route = route;
     }
     /** Create selection-aware routing while keeping auxiliary families disjoint. */
     static selectable(registry, auxiliaryProviders) {
@@ -48,99 +26,31 @@ export class SessionProviderRouter {
             if (auxiliaryOperations.has(operation))
                 throw new TypeError(`Deep and auxiliary providers both declare operation ${operation}`);
         const initialRoute = selectableRoute(auxiliaryProviders, undefined);
-        return new SessionProviderRouter({
-            kind: "selectable",
-            registry,
-            auxiliaryProviders: [...auxiliaryProviders],
-            identity: identities.length === 0
-                ? emptyProviderIdentity()
-                : compositeProviderIdentity(identities),
-            initialRoute,
-        });
-    }
-    /** Compatibility identity covering every configured provider. */
-    configuredIdentity() {
-        return structuredClone(this.runtime.identity);
-    }
-    /** Provider identities exposed through the flat 1.x compatibility field. */
-    providerIdentities(route) {
-        if (this.runtime.kind === "single") {
-            if (route.capabilities === undefined)
-                return [route.identity];
-            return uniqueProviderIdentities([...route.capabilities.values()].map(({ provider }) => provider));
-        }
-        const selected = route.binding?.identity;
-        return uniqueProviderIdentities([
-            ...this.runtime.auxiliaryProviders.map((provider) => provider.identity()),
-            ...this.runtime.registry
-                .identities()
-                .map((identity) => identity.id === selected?.id ? selected : identity),
-        ]);
+        return new SessionProviderRouter(registry, [...auxiliaryProviders], initialRoute);
     }
     /** Target-free routes and discovery metadata. */
     initialRoute() {
-        if (this.runtime.kind === "selectable")
-            return this.runtime.initialRoute;
-        const runtime = this.runtime;
-        return {
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: null,
-            compatibility: {},
-            binding: null,
-            selection: undefined,
-            createClient: (target, context) => createSingleProviderClient(runtime, target, undefined, context),
-        };
+        return this.route;
     }
     /** Resolve target routes before any provider client is created. */
     async resolve(target, providerId, signal) {
         const resolutionOptions = signal === undefined ? undefined : { signal };
-        if (this.runtime.kind === "selectable") {
-            const selected = await this.runtime.registry.select(target, providerId, resolutionOptions);
-            return selected.ok
-                ? ok(selectableRoute(this.runtime.auxiliaryProviders, selected.value))
-                : selected;
-        }
-        const runtime = this.runtime;
-        if (providerId !== undefined &&
-            providerId !== "auto" &&
-            providerId !== runtime.identity.id)
-            return err(new ProviderSelectionError({
-                reason: "unknown_provider",
-                requestedProviderId: providerId,
-                candidateIds: [runtime.identity.id],
-            }));
-        const resolved = await waitForAbortable(runtime.resolveProfile(target, resolutionOptions), signal);
-        if (resolved === ABORTED)
-            return err(new AnalysisCancelledError("open_binary"));
-        if (!resolved.ok)
-            return resolved;
-        const normalized = normalizeProfileResolution(resolved.value, runtime.identity.id);
-        if (!normalized.ok)
-            return normalized;
-        return ok({
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: normalized.value.profile,
-            compatibility: normalized.value.compatibility,
-            binding: null,
-            selection: undefined,
-            createClient: (openedTarget, context) => createSingleProviderClient(runtime, openedTarget, normalized.value.profile ?? undefined, context),
-        });
+        const selected = await this.registry.select(target, providerId, resolutionOptions);
+        return selected.ok
+            ? ok(selectableRoute(this.auxiliaryProviders, selected.value))
+            : selected;
     }
     /** Candidate status authoritative for the active or target-free route. */
     candidateStatuses(route) {
-        if (this.runtime.kind === "single")
-            return [];
-        return route.selection?.candidates ?? this.runtime.registry.candidates();
+        return route.selection?.candidates ?? this.registry.candidates();
     }
     /** Produce exact candidate rejections for an intentionally unbound route. */
     unboundOperationError(operation, route) {
-        if (this.runtime.kind !== "selectable" ||
-            route.binding !== null ||
-            route.selection === undefined)
+        if (route.binding !== null ||
+            route.selection === undefined ||
+            !this.registry.declaredOperations().includes(operation))
             return undefined;
-        return this.runtime.registry.unboundOperationError(operation, route.selection);
+        return this.registry.unboundOperationError(operation, route.selection);
     }
 }
 const selectableRoute = (auxiliaryProviders, selection) => {
@@ -149,23 +59,23 @@ const selectableRoute = (auxiliaryProviders, selection) => {
         ...auxiliaryProviders,
         ...(binding === null ? [] : [binding.provider]),
     ];
-    const provider = providers.length === 0 ? undefined : new CompositeProvider(providers);
+    const provider = binding === null && providers.length === 1
+        ? providers[0]
+        : providers.length === 0
+            ? undefined
+            : new CompositeProvider(providers);
     const identity = provider?.identity() ?? emptyProviderIdentity();
     const capabilities = capabilityMap(provider?.capabilities() ?? []);
     return {
         identity,
         capabilities,
         profile: binding?.profile ?? null,
-        compatibility: structuredClone(binding?.compatibility ?? {}),
         binding,
         selection,
         createClient: (target, context) => provider?.createClient(target, binding?.profile, context) ??
             emptyClient(identity),
     };
 };
-const createSingleProviderClient = (runtime, target, profile, context) => typeof runtime.provider === "function"
-    ? runtime.provider(target, profile, context)
-    : runtime.provider.createClient(target, profile, context);
 const emptyClient = (identity) => ({
     execute: (operation) => operation === "health"
         ? Promise.resolve(ok({
@@ -177,7 +87,7 @@ const emptyClient = (identity) => ({
             subject: null,
         }))
         : Promise.resolve(err(new AnalysisCapabilityUnavailableError(identity.id, operation, "operation is not declared by this provider set"))),
-    close: () => Promise.resolve(),
+    close: () => Promise.resolve(ok(null)),
 });
 const emptyProviderIdentity = () => ({
     id: "composite:none",
@@ -185,9 +95,6 @@ const emptyProviderIdentity = () => ({
     version: null,
 });
 const capabilityMap = (capabilities) => new Map(capabilities.map((descriptor) => [descriptor.operation, descriptor]));
-const uniqueProviderIdentities = (identities) => [...new Map(identities.map((identity) => [identity.id, identity])).values()]
-    .sort((left, right) => left.id.localeCompare(right.id))
-    .map((identity) => structuredClone(identity));
 const assertDisjoint = (providers) => {
     const routes = new Set();
     for (const provider of providers)
@@ -206,18 +113,3 @@ const assertUniqueProviderIds = (identities) => {
         ids.add(identity.id);
     }
 };
-const normalizeProfileResolution = (resolution, providerId) => {
-    try {
-        return ok({
-            profile: resolution.profile === null
-                ? null
-                : analysisProfileSchema.parse(resolution.profile),
-            compatibility: jsonObjectSchema.parse(resolution.compatibility),
-        });
-    }
-    catch (cause) {
-        return err(new ProviderAdapterError(providerId, "resolve_analysis_profile", {
-            cause,
-        }));
-    }
-};

package/dist/application/homebrew.js

@@ -1,3 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
 /** Standard executable names and locations used to discover Homebrew. */
 const HOMEBREW_COMMANDS = [
     "brew",
@@ -17,3 +20,48 @@ export const probeHomebrew = async (probe) => {
     }
     return undefined;
 };
+const caskDirectoriesSchema = z
+    .object({ appdir: z.string().min(1).optional() })
+    .loose();
+const caskConfigSchema = z
+    .object({
+    default: caskDirectoriesSchema.optional(),
+    env: caskDirectoriesSchema.optional(),
+    explicit: caskDirectoriesSchema.optional(),
+})
+    .loose();
+/**
+ * Read the application directory Homebrew recorded when it installed a cask,
+ * in Homebrew's precedence: explicit option, then environment, then default.
+ * Reading the Caskroom avoids `brew` cask commands, which refresh Homebrew's
+ * API and bootsnap caches.
+ */
+export const installedCaskAppdir = async (caskroom, token, home) => {
+    let text;
+    try {
+        text = await readFile(join(caskroom, token, ".metadata", "config.json"), "utf8");
+    }
+    catch (cause) {
+        // An absent or unreadable receipt means the cask is not installed here.
+        void cause;
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (cause) {
+        // A malformed receipt does not identify an application directory.
+        void cause;
+        return undefined;
+    }
+    const config = caskConfigSchema.safeParse(parsed);
+    if (!config.success)
+        return undefined;
+    const appdir = config.data.explicit?.appdir ??
+        config.data.env?.appdir ??
+        config.data.default?.appdir;
+    if (appdir === undefined)
+        return undefined;
+    return appdir.startsWith("~/") ? join(home, appdir.slice(2)) : appdir;
+};

package/dist/application/javascript/ElectronActiveEvidence.js

@@ -1,7 +1,7 @@
-import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
 import { createEvidence } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
-/** Create Evidence without retaining arbitrary runtime argument values. */
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+/** Commit the selected Electron experiment and its observed result. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
     predicateType: "rea.electron-active-scenario",
     operation: "capture_electron_scenario",
@@ -20,14 +20,10 @@ export const createElectronActiveEvidence = (input, result, provider) => createE
         "Application host platform and architecture were not observed.",
     ],
 });
-const scenarioProjection = (input) => ({
-    executable_path: input.executable_path,
-    application_path: input.application_path,
-    application_root: input.application_root,
-    args: [...input.args],
-    actions: input.actions.map(({ step_id, kind }) => ({ step_id, kind })),
-});
-const parameters = (input) => ({
-    ...scenarioProjection(input),
-    scenario_sha256: canonicalDigest(scenarioProjection(input), "Browser scenario"),
-});
+const parameters = (input) => {
+    const scenario = jsonObjectSchema.parse(input);
+    return {
+        ...scenario,
+        scenario_sha256: digestCanonicalValue(scenario, "Electron scenario"),
+    };
+};

package/dist/application/javascript/ElectronBoundaryAnalysis.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Flatten all per-file IPC facts into deterministic application records. */
 export const collectElectronIpcRecords = (analysis) => analysis.files
@@ -7,7 +7,7 @@ export const collectElectronIpcRecords = (analysis) => analysis.files
     file,
     finding,
 })))
-    .sort((left, right) => compareCodePoints(left.key, right.key));
+    .sort((left, right) => compareUnicodeCodePoints(left.key, right.key));
 /** Match only exact literal channels and retain ambiguous matches separately. */
 export const classifyElectronIpcPairings = (records) => {
     const handlers = records.filter(isMainHandler);

package/dist/application/javascript/ElectronBoundaryGraphNative.js

@@ -1,5 +1,6 @@
 import { javascriptAnalysisCoverage, resolveArtifactPath, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
 import { addElectronInferenceEdge, electronFindingSourceNode, electronObservationIdentity, electronRangeKey, } from "./ElectronBoundaryGraphContext.js";
 /** Project JavaScript-requested native addon binding and re-export surfaces. */
 export const addElectronNativeBoundaries = (context) => {
@@ -21,7 +22,10 @@ const addNativeBinding = (input) => {
     const addon = resolved === null ? undefined : context.fileNodes.get(resolved);
     const binding = context.accumulator.addNode({
         kind: "native-export",
-        identity: electronObservationIdentity(context, "javascript-requested-native-export", `${file.path}:${value.specifier}:${value.binding_kind}:${value.members.join("\0")}:${electronRangeKey(value.location)}`),
+        identity: electronObservationIdentity(context, "javascript-requested-native-export", 
+        // Members are a variable-length source-derived list: compositeKey keeps
+        // ["a\0b"] distinct from ["a", "b"] inside the digested identity.
+        `${file.path}:${value.specifier}:${value.binding_kind}:${compositeKey(value.members)}:${electronRangeKey(value.location)}`),
         observations: [
             {
                 label: value.members.join(", "),

package/dist/application/javascript/JavaScriptApplicationEvidence.js

@@ -1,11 +1,9 @@
-import { createEvidence, createImmutableEvidenceSteps, } from "../../domain/evidence.js";
+import { createImmutableEvidenceSteps, } from "../../domain/evidence.js";
 import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
-import { freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, } from "../../domain/immutableJson.js";
+import { freezeOwnedJsonSnapshotSteps } from "../../domain/immutableJson.js";
 import { rememberOwnedApplicationGraphEvidence } from "./JavaScriptApplicationEvidenceGraph.js";
 import { completeJavaScriptAnalysisSteps } from "./JavaScriptAnalysisControl.js";
 import { jsonValueValidationSteps } from "../../domain/jsonValue.js";
-/** Transfer an already validated, application-owned result into immutable analysis Evidence. */
-export const createOwnedJavaScriptApplicationEvidence = (input, result) => rememberOwnedApplicationGraphEvidence(createJavaScriptApplicationEvidence(input, freezeJsonSnapshot(result)), result);
 /** Create owned analysis Evidence while allowing request cancellation during sealing and hashing. */
 export const createOwnedJavaScriptApplicationEvidenceCooperatively = async (input, result, signal, progress) => {
     await reportEvidencePhase(progress, "seal_javascript_application_result", "Sealing the complete application analysis result");
@@ -19,8 +17,6 @@ export const createOwnedJavaScriptApplicationEvidenceCooperatively = async (inpu
 };
 const reportEvidencePhase = (progress, phase, message) => progress?.report({ phase, completed: 0, total: 1, message }) ??
     Promise.resolve();
-/** Create Evidence for one deterministic local JavaScript application graph. */
-export const createJavaScriptApplicationEvidence = (input, result) => createEvidence(applicationSubject(result), JAVASCRIPT_APPLICATION_PROVIDER, applicationObservation(input, result));
 const applicationSubject = (result) => ({
     path: result.input_path,
     sha256: result.root_artifact_sha256,
@@ -40,4 +36,5 @@ const applicationObservation = (input, result) => ({
 });
 const parameters = (input) => ({
     format: input.format,
+    integrity_policy: input.integrity_policy,
 });