rea-agents 1.7.0 → 2.1.0

package/dist/application/BinarySessionStatus.js

@@ -0,0 +1,75 @@
+/** Project internal provider routing state into the caller-visible session status. */
+export const binarySessionStatus = ({ target, route, router, runtimeAvailability, }) => {
+    const configuredProvider = router.configuredIdentity();
+    const provider = providerSummary(configuredProvider);
+    const providers = router.providerIdentities(route).map(providerSummary);
+    const capabilities = [...(route.capabilities?.values() ?? [])]
+        .sort((left, right) => left.operation.localeCompare(right.operation))
+        .map((descriptor) => ({
+        ...descriptor,
+        ...runtimeAvailability.get(descriptor.operation),
+    }))
+        .map(capabilityStatus);
+    const analysisProviderBinding = route.binding === null
+        ? null
+        : {
+            provider: providerSummary(route.binding.identity),
+            selection_source: route.binding.selectionSource,
+            analysis_profile: structuredClone(route.binding.profile),
+        };
+    const analysisProviderCandidates = router
+        .candidateStatuses(route)
+        .map((candidate) => ({
+        provider: providerSummary(candidate.provider),
+        availability: structuredClone(candidate.availability),
+        target_support: structuredClone(candidate.targetSupport),
+        selected: candidate.selected,
+        capabilities: candidate.capabilities
+            .slice()
+            .sort((left, right) => left.operation.localeCompare(right.operation))
+            .map(capabilityStatus),
+    }));
+    const common = {
+        provider,
+        providers,
+        capabilities,
+        analysis_provider_binding: analysisProviderBinding,
+        analysis_provider_candidates: analysisProviderCandidates,
+    };
+    return target === undefined
+        ? { open: false, ...common }
+        : {
+            open: true,
+            ...common,
+            path: target.path,
+            sha256: target.sha256,
+            format: target.format,
+            kind: target.kind,
+            architecture: target.architecture ?? null,
+        };
+};
+const providerSummary = ({ id, name, version, }) => ({ id, name, version });
+const capabilityStatus = (descriptor) => ({
+    operation: descriptor.operation,
+    available: descriptor.available,
+    reason: descriptor.reason,
+    input_contract_version: descriptor.inputContractVersion,
+    output_contract_version: descriptor.outputContractVersion,
+    pagination: descriptor.pagination,
+    exhaustive: descriptor.exhaustive,
+    effects: {
+        mutates_artifact: descriptor.effects.mutatesArtifact,
+        launches_process: descriptor.effects.launchesProcess,
+        may_show_ui: descriptor.effects.mayShowUi,
+        may_access_network: descriptor.effects.mayAccessNetwork,
+        may_write_filesystem: descriptor.effects.mayWriteFilesystem,
+        changes_permissions: descriptor.effects.changesPermissions,
+        requires_root: descriptor.effects.requiresRoot,
+    },
+    limits: {
+        max_results: descriptor.limits.maxResults,
+        max_payload_bytes: descriptor.limits.maxPayloadBytes,
+        timeout_ms: descriptor.limits.timeoutMs,
+    },
+    limitations: [...descriptor.limitations],
+});

package/dist/application/CapabilityInventory.js

@@ -37,13 +37,21 @@ export const buildCapabilityInventory = (sessionStatus, policy) => {
     const status = statusSchema.parse(sessionStatus);
     const descriptors = new Map(status.capabilities.map((descriptor) => [descriptor.operation, descriptor]));
     return TOOL_CONTRACTS.map((contract) => {
-        const availability = availabilityFor(contract.name, contract.kind, status.open, status.kind, descriptors, policy);
+        const availability = availabilityFor({
+            name: contract.name,
+            kind: contract.kind,
+            targetOpen: status.open,
+            targetKind: status.kind,
+            descriptors,
+            policy,
+        });
         return {
             name: contract.name,
             surface: contract.kind,
             available: availability.reason === "available",
             reason: availability.reason,
             remediation: availability.remediation,
+            effects: { ...contract.effects },
             annotations: {
                 read_only: contract.annotations.readOnlyHint ?? false,
                 destructive: contract.annotations.destructiveHint ?? false,
@@ -53,12 +61,38 @@ export const buildCapabilityInventory = (sessionStatus, policy) => {
         };
     }).sort((left, right) => left.name.localeCompare(right.name));
 };
-const availabilityFor = (name, kind, targetOpen, targetKind, descriptors, policy) => {
+const availabilityFor = (context) => {
+    const policyDecision = policyAvailability(context);
+    if (policyDecision !== null)
+        return policyDecision;
+    const targetDecision = targetAvailability(context);
+    if (targetDecision !== null)
+        return targetDecision;
+    return providerAvailability(context);
+};
+const policyAvailability = ({ name, kind, policy, }) => {
     if (name === "capture_process_scenario" && !policy.processCaptureEnabled)
         return {
             reason: "policy_disabled",
             remediation: "Enable or grant process_capture within the administrator ceiling.",
         };
+    if (name === "run_controlled_replay" && !policy.javascriptReplayEnabled)
+        return {
+            reason: "policy_disabled",
+            remediation: "Enable javascript_replay with exact source roots and sandbox executables.",
+        };
+    if (name === "run_controlled_replay")
+        return { reason: "available", remediation: null };
+    if (name === "plan_managed_runtime_correlation" &&
+        !policy.managedRuntimeEnabled)
+        return {
+            reason: "policy_disabled",
+            remediation: "Enable managed_runtime with exact artifact roots and a runtime executable.",
+        };
+    if (name === "plan_managed_runtime_correlation")
+        return { reason: "available", remediation: null };
+    if (kind === "application")
+        return { reason: "available", remediation: null };
     if (name === "import_evidence_bundle" && policy.evidenceFileRoots === 0)
         return {
             reason: "policy_disabled",
@@ -80,6 +114,9 @@ const availabilityFor = (name, kind, targetOpen, targetKind, descriptors, policy
             };
     if (kind === "session")
         return { reason: "available", remediation: null };
+    return null;
+};
+const targetAvailability = ({ kind, targetKind, targetOpen, }) => {
     if (!targetOpen)
         return {
             reason: "target_required",
@@ -93,6 +130,9 @@ const availabilityFor = (name, kind, targetOpen, targetKind, descriptors, policy
             reason: "target_unsupported",
             remediation: "Inventory or extract a native executable, then call open_binary on that executable.",
         };
+    return null;
+};
+const providerAvailability = ({ descriptors, kind, name, }) => {
     if (kind === "enhanced")
         return composedAvailability(name, descriptors);
     const descriptor = descriptors.get(name);

package/dist/application/ClientRegistrationStatus.js

@@ -39,7 +39,7 @@ const registrationAligned = (command, currentCommandPath) => {
     if (command.length === 4 &&
         command[0] === "npx" &&
         command[1] === "-y" &&
-        command[2] === PRODUCT_IDENTITY.packageName &&
+        command[2] === PRODUCT_IDENTITY.packageSpecifier &&
         command[3] === "mcp")
         return true;
     return (command.length === 2 &&

package/dist/application/CrossVersionInventory.js

@@ -10,8 +10,14 @@ export const AUTOMATIC_RUN_LIMITATION = "Automatic cross-version runs compare sh
 /** Start both independent version scans while preserving left/right identity. */
 export const scanVersionInventories = async (options, scanner = scanAuthorizedArtifactInventory) => {
     const [left, right] = await Promise.all([
-        scanner(options.leftPath, options.inputRoots, options.limits, options.signal, options.integrity),
-        scanner(options.rightPath, options.inputRoots, options.limits, options.signal, options.integrity),
+        scanner(options.leftPath, options.inputRoots, options.limits, {
+            signal: options.signal,
+            integrity: options.integrity,
+        }),
+        scanner(options.rightPath, options.inputRoots, options.limits, {
+            signal: options.signal,
+            integrity: options.integrity,
+        }),
     ]);
     return { left, right };
 };

package/dist/application/CrossVersionInvestigation.js

@@ -7,6 +7,7 @@ import { createInventoryEvidencePages, runLimitations, scanVersions, targetFor,
 import { readInvestigationWorkspace, writeInvestigationWorkspace, } from "./InvestigationWorkspaceStore.js";
 import { createArtifactComparisonEvidence, createChangedBehaviorEvidence, } from "./CrossVersionInvestigationEvidence.js";
 import { selectCompletedInvestigationReplay } from "./CrossVersionInvestigationReplay.js";
+import { investigationEvidenceIds as evidenceIds, mergeInvestigationEvidence as mergeEvidence, recordsForInvestigationRun as recordsForRun, replaceInvestigationRun as replaceRun, } from "./CrossVersionInvestigationCollections.js";
 /** Run or resume a deterministic cross-version artifact investigation. */
 export const runCrossVersionInvestigation = async (input, policy, execution) => {
     const parsed = crossVersionInvestigationInputSchema.safeParse(input);
@@ -14,16 +15,20 @@ export const runCrossVersionInvestigation = async (input, policy, execution) =>
         return err(new AnalysisInputError("find_changed_behavior", {
             cause: parsed.error,
         }));
-    const initial = await readInvestigationWorkspace(parsed.data.workspace_path, policy);
+    return runCrossVersionInvestigationValidated(parsed.data, policy, execution);
+};
+/** Run input already parsed by a trusted adapter boundary. */
+export const runCrossVersionInvestigationValidated = async (input, policy, execution) => {
+    const initial = await readInvestigationWorkspace(input.workspace_path, policy);
     if (!initial.ok)
         return initial;
-    const preflight = validateWorkspaceRequest(initial.value, parsed.data);
+    const preflight = validateWorkspaceRequest(initial.value, input);
     if (!preflight.ok)
         return preflight;
     if (isCancelled(execution.signal))
         return err(new AnalysisCancelledError("find_changed_behavior"));
-    if (parsed.data.replay_run_id !== undefined) {
-        const replay = selectCompletedInvestigationReplay(initial.value, parsed.data);
+    if (input.replay_run_id !== undefined) {
+        const replay = selectCompletedInvestigationReplay(initial.value, input);
         if (!replay.ok)
             return replay;
         return completeOutcome(replay.value.workspace, replay.value.run, true, execution.session);
@@ -39,7 +44,7 @@ export const runCrossVersionInvestigation = async (input, policy, execution) =>
         total: 4,
         message: "Scanning both version inputs",
     });
-    const snapshots = await scanVersions(parsed.data, execution.inputRoots, execution.signal, execution.integrityContinueEnabled);
+    const snapshots = await scanVersions(input, execution.inputRoots, execution.signal, execution.integrityContinueEnabled);
     if (!snapshots.ok)
         return snapshots;
     await execution.progress?.report({
@@ -49,7 +54,7 @@ export const runCrossVersionInvestigation = async (input, policy, execution) =>
         message: "Version inputs scanned",
     });
     return continueInvestigation({
-        input: parsed.data,
+        input,
         initial: initial.value,
         snapshots: snapshots.value,
         policy,
@@ -294,26 +299,3 @@ const inventoryEvidence = (workspace, run) => {
         ? ok({ left, right })
         : err(new EvidenceIntegrityError("Investigation inventory checkpoint is incomplete"));
 };
-const recordsForRun = (workspace, run) => {
-    const ids = new Set([
-        ...run.left_inventory_evidence_ids,
-        ...run.right_inventory_evidence_ids,
-        ...(run.comparison_evidence_id === null
-            ? []
-            : [run.comparison_evidence_id]),
-        ...(run.result_evidence_id === null ? [] : [run.result_evidence_id]),
-    ]);
-    return workspace.bundle.records.filter(({ evidence_id: id }) => ids.has(id));
-};
-const mergeEvidence = (current, additions) => {
-    const records = new Map(current.map((record) => [record.evidence_id, record]));
-    for (const record of additions)
-        if (!records.has(record.evidence_id))
-            records.set(record.evidence_id, record);
-    return [...records.values()];
-};
-const replaceRun = (runs, replacement) => [
-    ...runs.filter(({ run_id: id }) => id !== replacement.run_id),
-    replacement,
-];
-const evidenceIds = (records) => records.map(({ evidence_id: id }) => id);

package/dist/application/CrossVersionInvestigationCollections.js

@@ -0,0 +1,23 @@
+export const recordsForInvestigationRun = (workspace, run) => {
+    const ids = new Set([
+        ...run.left_inventory_evidence_ids,
+        ...run.right_inventory_evidence_ids,
+        ...(run.comparison_evidence_id === null
+            ? []
+            : [run.comparison_evidence_id]),
+        ...(run.result_evidence_id === null ? [] : [run.result_evidence_id]),
+    ]);
+    return workspace.bundle.records.filter(({ evidence_id: id }) => ids.has(id));
+};
+export const mergeInvestigationEvidence = (current, additions) => {
+    const records = new Map(current.map((record) => [record.evidence_id, record]));
+    for (const record of additions)
+        if (!records.has(record.evidence_id))
+            records.set(record.evidence_id, record);
+    return [...records.values()];
+};
+export const replaceInvestigationRun = (runs, replacement) => [
+    ...runs.filter(({ run_id: id }) => id !== replacement.run_id),
+    replacement,
+];
+export const investigationEvidenceIds = (records) => records.map(({ evidence_id: id }) => id);

package/dist/application/DirectAnalysis.js

@@ -31,7 +31,7 @@ export const runDirectAnalysis = async (path, tool, arguments_, options = {}) =>
         : { permissionAuthority: options.permissionAuthority }),
 }));
 /** Execute one provider-native semantic operation with atomic provenance. */
-export const runProviderAnalysis = async (path, tool, arguments_, logger = silentLogger, signal) => withProcessCancellation(signal, (operationSignal) => runAnalysis(path, tool, arguments_, {
+export const runProviderAnalysis = async (...[path, tool, arguments_, logger = silentLogger, signal]) => withProcessCancellation(signal, (operationSignal) => runAnalysis(path, tool, arguments_, {
     logger,
     snapshotPath: undefined,
     signal: operationSignal,
@@ -172,49 +172,14 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         const writable = await authorizeDeferredWrite(authorization.value);
         if (!writable.ok)
             return cliError(writable.error);
-        let output;
-        let evidence;
-        if (tool === "binary_overview" ||
-            tool === "analyze_function" ||
-            tool === "trace_feature") {
-            const result = await new EnhancedTools(session).execute(tool, arguments_, signal);
-            if (!result.ok)
-                output = cliError(result.error);
-            else {
-                evidence = createEvidence(opened.value, tool === "analyze_function"
-                    ? session.providerIdentity(tool)
-                    : REA_WORKFLOW_PROVIDER, {
-                    operation: tool,
-                    parameters: arguments_,
-                    result: result.value,
-                    ...(evidenceProfile === undefined
-                        ? {}
-                        : { analysisProfile: evidenceProfile }),
-                    confidence: "derived",
-                    limitations: ["Derived by an REA composed workflow."],
-                });
-                output = evidence;
-            }
-        }
-        else {
-            const result = await session.execute(tool, arguments_, { signal });
-            if (!result.ok)
-                output = cliError(result.error);
-            else {
-                evidence = createEvidence(result.value.subject ?? opened.value, result.value.provider, {
-                    operation: tool,
-                    parameters: arguments_,
-                    result: result.value.result,
-                    ...(result.value.analysisProfile === undefined
-                        ? {}
-                        : { analysisProfile: result.value.analysisProfile }),
-                    rawResult: result.value.rawResult,
-                    limitations: result.value.limitations,
-                    locations: result.value.locations,
-                });
-                output = evidence;
-            }
-        }
+        const { output, evidence } = await executeAnalysisTool({
+            session,
+            openedTarget: opened.value,
+            tool,
+            arguments: arguments_,
+            signal,
+            evidenceProfile,
+        });
         if (evidence !== undefined)
             session.recordEvidence(evidence);
         if (snapshotPath !== undefined && evidence !== undefined) {
@@ -231,6 +196,44 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         await session.close();
     }
 };
+const executeAnalysisTool = async (input) => {
+    const { session, tool, signal, evidenceProfile } = input;
+    if (tool === "binary_overview" ||
+        tool === "analyze_function" ||
+        tool === "trace_feature") {
+        const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
+        if (!result.ok)
+            return { output: cliError(result.error) };
+        const evidence = createEvidence(input.openedTarget, tool === "analyze_function"
+            ? session.providerIdentity(tool)
+            : REA_WORKFLOW_PROVIDER, {
+            operation: tool,
+            parameters: input.arguments,
+            result: result.value,
+            ...(evidenceProfile === undefined
+                ? {}
+                : { analysisProfile: evidenceProfile }),
+            confidence: "derived",
+            limitations: ["Derived by an REA composed workflow."],
+        });
+        return { output: evidence, evidence };
+    }
+    const result = await session.execute(tool, input.arguments, { signal });
+    if (!result.ok)
+        return { output: cliError(result.error) };
+    const evidence = createEvidence(result.value.subject ?? input.openedTarget, result.value.provider, {
+        operation: tool,
+        parameters: input.arguments,
+        result: result.value.result,
+        ...(result.value.analysisProfile === undefined
+            ? {}
+            : { analysisProfile: result.value.analysisProfile }),
+        rawResult: result.value.rawResult,
+        limitations: result.value.limitations,
+        locations: result.value.locations,
+    });
+    return { output: evidence, evidence };
+};
 const withProcessCancellation = async (suppliedSignal, operation) => {
     if (suppliedSignal !== undefined)
         return operation(suppliedSignal);