rea-agents 1.2.0 → 1.4.0

package/dist/application/CrossVersionInvestigation.js

@@ -0,0 +1,358 @@
+import { compareArtifacts } from "../domain/artifactComparison.js";
+import { findChangedBehavior } from "../domain/changedBehavior.js";
+import { createEvidence } from "../domain/evidence.js";
+import { createEvidenceBundle, } from "../domain/evidenceBundle.js";
+import { AnalysisCancelledError, AnalysisInputError, EvidenceIntegrityError, InvestigationWorkspaceError, } from "../domain/errors.js";
+import { createLegacyInvestigationRunIdentity, createInvestigationRunIdentity, createInvestigationWorkspace, crossVersionInvestigationInputSchema, investigationRunSchema, investigationRunSummarySchema, reviseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { AUTOMATIC_RUN_LIMITATION, createInventoryEvidencePages, runLimitations, scanVersions, targetFor, } from "./CrossVersionInventory.js";
+import { readInvestigationWorkspace, writeInvestigationWorkspace, } from "./InvestigationWorkspaceStore.js";
+import { ARTIFACT_COMPARISON_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, } from "./InvestigationProviders.js";
+/** Run or resume a deterministic cross-version artifact investigation. */
+export const runCrossVersionInvestigation = async (input, policy, execution) => {
+    const parsed = crossVersionInvestigationInputSchema.safeParse(input);
+    if (!parsed.success)
+        return err(new AnalysisInputError("find_changed_behavior", {
+            cause: parsed.error,
+        }));
+    const initial = await readInvestigationWorkspace(parsed.data.workspace_path, policy);
+    if (!initial.ok)
+        return initial;
+    const preflight = validateWorkspaceRequest(initial.value, parsed.data);
+    if (!preflight.ok)
+        return preflight;
+    if (isCancelled(execution.signal))
+        return err(new AnalysisCancelledError("find_changed_behavior"));
+    await execution.progress?.report({
+        phase: "scan_versions",
+        completed: 0,
+        total: 4,
+        message: "Scanning both version inputs",
+    });
+    const snapshots = await scanVersions(parsed.data, execution.inputRoots, execution.signal, execution.integrityContinueEnabled);
+    if (!snapshots.ok)
+        return snapshots;
+    await execution.progress?.report({
+        phase: "scan_versions",
+        completed: 1,
+        total: 4,
+        message: "Version inputs scanned",
+    });
+    return continueInvestigation({
+        input: parsed.data,
+        initial: initial.value,
+        snapshots: snapshots.value,
+        policy,
+        session: execution.session,
+        signal: execution.signal,
+        progress: execution.progress,
+    });
+};
+const continueInvestigation = async (context) => {
+    const left = targetFor(context.snapshots.left);
+    const right = targetFor(context.snapshots.right);
+    const identity = createInvestigationRunIdentity({
+        left,
+        right,
+        options: context.input.options,
+        integrity_policy: context.input.integrity_policy,
+        integrity_continue_approved: context.input.integrity_continue_approved,
+        max_integrity_mismatches: context.input.max_integrity_mismatches,
+    });
+    const legacyIdentity = createLegacyInvestigationRunIdentity({
+        left,
+        right,
+        options: context.input.options,
+    });
+    const existing = context.initial?.runs.find((run) => run.run_id === identity.runId ||
+        (context.input.integrity_policy === "fail" &&
+            !context.input.integrity_continue_approved &&
+            context.input.max_integrity_mismatches === 10 &&
+            "legacy_request_identity" in run &&
+            run.max_integrity_mismatches === 10 &&
+            run.run_id === legacyIdentity.runId));
+    if (context.initial !== null && existing?.status === "complete")
+        return completeOutcome(context.initial, existing, true, context.session);
+    const pages = createInventoryEvidencePages(context.input, context.snapshots);
+    if (!pages.ok)
+        return pages;
+    if (isCancelled(context.signal))
+        return err(new AnalysisCancelledError("find_changed_behavior"));
+    const inventoried = await ensureInventoryCheckpoint({
+        input: context.input,
+        current: context.initial,
+        existing,
+        pages: pages.value,
+        snapshots: context.snapshots,
+        policy: context.policy,
+    });
+    if (!inventoried.ok)
+        return inventoried;
+    await context.progress?.report({
+        phase: "inventory_versions",
+        completed: 2,
+        total: 4,
+        message: "Both artifact inventories checkpointed",
+    });
+    if (isCancelled(context.signal))
+        return err(new AnalysisCancelledError("find_changed_behavior"));
+    const compared = await ensureComparisonCheckpoint(context.input, inventoried.value, context.policy);
+    if (!compared.ok)
+        return compared;
+    await context.progress?.report({
+        phase: "compare_artifacts",
+        completed: 3,
+        total: 4,
+        message: "Artifact comparison checkpointed",
+    });
+    if (isCancelled(context.signal))
+        return err(new AnalysisCancelledError("find_changed_behavior"));
+    const finalized = await finalizeInvestigation(context.input, compared.value, context.policy, context.session);
+    await context.progress?.report({
+        phase: "changed_behavior",
+        completed: 4,
+        total: 4,
+        message: finalized.ok ? "Investigation completed" : "Investigation failed",
+        terminal: true,
+    });
+    return finalized;
+};
+const isCancelled = (signal) => signal?.aborted === true;
+const ensureInventoryCheckpoint = async (input) => {
+    if (input.existing !== undefined) {
+        const consistent = validateInventoryCheckpoint(input.existing, input.pages);
+        if (!consistent.ok)
+            return consistent;
+        return input.current === null
+            ? err(new EvidenceIntegrityError("Investigation workspace is missing"))
+            : ok({ workspace: input.current, run: input.existing });
+    }
+    const left = targetFor(input.snapshots.left);
+    const right = targetFor(input.snapshots.right);
+    const identity = createInvestigationRunIdentity({
+        left,
+        right,
+        options: input.input.options,
+        integrity_policy: input.input.integrity_policy,
+        integrity_continue_approved: input.input.integrity_continue_approved,
+        max_integrity_mismatches: input.input.max_integrity_mismatches,
+    });
+    const run = investigationRunSchema.parse({
+        schema_version: 1,
+        run_id: identity.runId,
+        request_sha256: identity.requestSha256,
+        left,
+        right,
+        options: input.input.options,
+        integrity_policy: input.input.integrity_policy,
+        integrity_continue_approved: input.input.integrity_continue_approved,
+        max_integrity_mismatches: input.input.max_integrity_mismatches,
+        status: "running",
+        completed_stages: ["inventory_left", "inventory_right"],
+        left_inventory_evidence_ids: evidenceIds(input.pages.left),
+        right_inventory_evidence_ids: evidenceIds(input.pages.right),
+        comparison_evidence_id: null,
+        result_evidence_id: null,
+        limitations: runLimitations(input.snapshots),
+    });
+    const saved = await checkpoint({
+        path: input.input.workspace_path,
+        name: input.input.workspace_name,
+        current: input.current,
+        records: [...input.pages.left, ...input.pages.right],
+        run,
+        policy: input.policy,
+    });
+    return saved.ok ? ok({ workspace: saved.value, run }) : saved;
+};
+const ensureComparisonCheckpoint = async (input, state, policy) => {
+    if (state.run.comparison_evidence_id !== null)
+        return ok(state);
+    const inventory = inventoryEvidence(state.workspace, state.run);
+    if (!inventory.ok)
+        return inventory;
+    const evidence = createArtifactComparisonEvidence(inventory.value, input.options.change_limit);
+    const run = investigationRunSchema.parse({
+        ...state.run,
+        completed_stages: [
+            "inventory_left",
+            "inventory_right",
+            "compare_artifacts",
+        ],
+        comparison_evidence_id: evidence.evidence_id,
+    });
+    const saved = await checkpoint({
+        path: input.workspace_path,
+        name: input.workspace_name,
+        current: state.workspace,
+        records: [evidence],
+        run,
+        policy,
+    });
+    return saved.ok ? ok({ workspace: saved.value, run }) : saved;
+};
+const createArtifactComparisonEvidence = (inventory, limit) => {
+    const comparison = compareArtifacts(inventory.left, inventory.right, 0, limit);
+    const leftIds = evidenceIds(inventory.left);
+    const rightIds = evidenceIds(inventory.right);
+    return createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
+        predicateType: "rea.artifact-comparison/v1",
+        operation: "compare_artifacts",
+        parameters: {
+            left_evidence_ids: leftIds,
+            right_evidence_ids: rightIds,
+            offset: 0,
+            limit,
+        },
+        result: jsonValueSchema.parse(comparison),
+        confidence: "derived",
+        authority: "analyst-inference",
+        limitations: comparison.limitations,
+        evidenceLinks: [...leftIds, ...rightIds],
+    });
+};
+const finalizeInvestigation = async (input, state, policy, session) => {
+    const comparison = comparisonEvidenceFor(state.workspace, state.run);
+    if (!comparison.ok)
+        return comparison;
+    const evidence = createChangedBehaviorEvidence(state, comparison.value);
+    const run = investigationRunSchema.parse({
+        ...state.run,
+        status: "complete",
+        completed_stages: [
+            "inventory_left",
+            "inventory_right",
+            "compare_artifacts",
+            "find_changed_behavior",
+        ],
+        result_evidence_id: evidence.evidence_id,
+    });
+    const saved = await checkpoint({
+        path: input.workspace_path,
+        name: input.workspace_name,
+        current: state.workspace,
+        records: [evidence],
+        run,
+        policy,
+    });
+    return saved.ok ? completeOutcome(saved.value, run, false, session) : saved;
+};
+const createChangedBehaviorEvidence = (state, comparison) => {
+    const limit = Math.min(state.run.options.change_limit, 100);
+    const changed = findChangedBehavior([comparison], 0, limit);
+    const summary = investigationRunSummarySchema.parse({
+        schema_version: 1,
+        workspace_id: state.workspace.workspace_id,
+        run_id: state.run.run_id,
+        left_manifest_id: state.run.left.manifest_id,
+        right_manifest_id: state.run.right.manifest_id,
+        inventory_evidence_count: state.run.left_inventory_evidence_ids.length +
+            state.run.right_inventory_evidence_ids.length,
+        comparison_evidence_id: comparison.evidence_id,
+        limitations: state.run.limitations,
+    });
+    return createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
+        predicateType: "rea.changed-behavior/v1",
+        operation: "find_changed_behavior",
+        parameters: {
+            workspace_id: state.workspace.workspace_id,
+            run_id: state.run.run_id,
+            comparison_evidence_ids: [comparison.evidence_id],
+            offset: 0,
+            limit,
+        },
+        result: jsonValueSchema.parse({
+            ...changed,
+            investigation_run: summary,
+        }),
+        confidence: "derived",
+        authority: "analyst-inference",
+        limitations: [...changed.limitations, AUTOMATIC_RUN_LIMITATION],
+        evidenceLinks: changed.evidence_links,
+    });
+};
+const comparisonEvidenceFor = (workspace, run) => {
+    const evidence = workspace.bundle.records.find(({ evidence_id: id }) => id === run.comparison_evidence_id);
+    return evidence === undefined
+        ? err(new EvidenceIntegrityError("Investigation comparison checkpoint is missing Evidence"))
+        : ok(evidence);
+};
+const checkpoint = async (input) => {
+    const records = mergeEvidence(input.current?.bundle.records ?? [], input.records);
+    const bundle = createEvidenceBundle(records, input.current?.bundle.unknowns ?? []);
+    const runs = replaceRun(input.current?.runs ?? [], input.run);
+    const next = input.current === null
+        ? createInvestigationWorkspace(input.name, bundle, runs)
+        : reviseInvestigationWorkspace(input.current, bundle, runs);
+    const written = await writeInvestigationWorkspace(next, input.path, input.current?.revision ?? null, input.policy);
+    return written.ok ? ok(next) : written;
+};
+const completeOutcome = (workspace, run, reused, session) => {
+    if (run.result_evidence_id === null)
+        return err(new EvidenceIntegrityError("Completed investigation has no result"));
+    const evidence = workspace.bundle.records.find(({ evidence_id: id }) => id === run.result_evidence_id);
+    if (evidence === undefined)
+        return err(new EvidenceIntegrityError("Completed investigation result Evidence is missing"));
+    if (session !== undefined) {
+        const records = recordsForRun(workspace, run);
+        const imported = session.importEvidenceBundle(createEvidenceBundle(records));
+        if (!imported.ok)
+            return imported;
+    }
+    return ok({ evidence, workspace, reused });
+};
+const validateWorkspaceRequest = (workspace, input) => {
+    if (workspace !== null && workspace.name !== input.workspace_name)
+        return err(new InvestigationWorkspaceError("update", "name-conflict"));
+    if (input.expected_workspace_revision !== undefined &&
+        workspace?.revision !== input.expected_workspace_revision)
+        return err(new InvestigationWorkspaceError("update", "revision-conflict"));
+    return ok(null);
+};
+const validateInventoryCheckpoint = (run, pages) => JSON.stringify(run.left_inventory_evidence_ids) ===
+    JSON.stringify(evidenceIds(pages.left)) &&
+    JSON.stringify(run.right_inventory_evidence_ids) ===
+        JSON.stringify(evidenceIds(pages.right))
+    ? ok(null)
+    : err(new EvidenceIntegrityError("Investigation inventory checkpoint disagrees with current content"));
+const inventoryEvidence = (workspace, run) => {
+    if (workspace === null)
+        return err(new EvidenceIntegrityError("Investigation workspace is missing"));
+    const byId = new Map(workspace.bundle.records.map((record) => [record.evidence_id, record]));
+    const left = run.left_inventory_evidence_ids.flatMap((id) => {
+        const evidence = byId.get(id);
+        return evidence === undefined ? [] : [evidence];
+    });
+    const right = run.right_inventory_evidence_ids.flatMap((id) => {
+        const evidence = byId.get(id);
+        return evidence === undefined ? [] : [evidence];
+    });
+    return left.length === run.left_inventory_evidence_ids.length &&
+        right.length === run.right_inventory_evidence_ids.length
+        ? 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/DirectAnalysis.js

@@ -1,8 +1,17 @@
 import { parseConfig } from "../config.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { createServerIdentity } from "../serverIdentity.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { createBinarySession } from "./runtime.js";
 import { silentLogger } from "../logger.js";
 import { createEvidence } from "../domain/evidence.js";
+import { EvidenceIntegrityError, AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { access } from "node:fs/promises";
+import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./AnalysisSnapshotFiles.js";
+import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
+import { err, ok } from "../domain/result.js";
+import { loadConfiguredPermissionAuthority } from "./PermissionConfiguration.js";
 const WORKFLOW_PROVIDER = {
     id: "rea-workflow",
     name: "REA composed investigation workflow",
@@ -13,37 +22,133 @@ const WORKFLOW_PROVIDER = {
  * Unlike MCP mode, every CLI invocation is intentionally isolated and does not
  * retain a target or bridge resources for a subsequent command.
  */
-export const runDirectAnalysis = async (path, tool, arguments_, logger = silentLogger) => runAnalysis(path, tool, arguments_, logger);
+export const runDirectAnalysis = async (path, tool, arguments_, options = {}) => withProcessCancellation(options.signal, (signal) => runAnalysis(path, tool, arguments_, {
+    logger: options.logger ?? silentLogger,
+    snapshotPath: options.snapshotPath,
+    signal,
+}));
 /** Execute one provider-native semantic operation with atomic provenance. */
-export const runProviderAnalysis = async (path, tool, arguments_, logger = silentLogger) => runAnalysis(path, tool, arguments_, logger);
+export const runProviderAnalysis = async (path, tool, arguments_, logger = silentLogger, signal) => withProcessCancellation(signal, (operationSignal) => runAnalysis(path, tool, arguments_, {
+    logger,
+    snapshotPath: undefined,
+    signal: operationSignal,
+}));
 /** Describe configured providers without opening a target or launching Hopper. */
 export const runSessionStatus = async (logger = silentLogger) => {
     const config = parseConfig(process.env);
     if (!config.ok)
-        return { error: config.error._tag, message: config.error.message };
+        return cliError(config.error);
     const session = createBinarySession(config.value, logger);
     try {
-        return session.status();
+        return {
+            ...jsonObjectSchema.parse(session.status()),
+            server_identity: createServerIdentity({
+                startedAt: new Date().toISOString(),
+            }),
+        };
     }
     finally {
         await session.close();
     }
 };
-const runAnalysis = async (path, tool, arguments_, logger) => {
+const authorizeAnalysis = async (authority, tool, arguments_, snapshotPath) => {
+    const requests = [];
+    if (snapshotPath !== undefined) {
+        requests.push({
+            capability: "snapshot_read",
+            path: snapshotPath,
+            access: "write",
+        }, {
+            capability: "snapshot_write",
+            path: snapshotPath,
+            access: "write",
+        });
+    }
+    if (tool === "extract_artifact" && typeof arguments_.output_root === "string")
+        requests.push({
+            capability: "artifact_extract",
+            path: arguments_.output_root,
+            access: "write",
+        });
+    for (const request of requests) {
+        const result = await authority.authorize({
+            capability: request.capability,
+            roots: [request.path],
+            executables: [],
+            environment_names: [],
+            network: "none",
+            mount: false,
+            operation_identity: `${tool}:${request.capability}:${request.path}`,
+        }, request.access);
+        if (!result.ok)
+            return err(result.error instanceof PermissionRequiredError
+                ? result.error
+                : new AnalysisProtocolError(result.error.message, {
+                    cause: result.error,
+                }));
+    }
+    if (tool === "inventory_artifact" &&
+        arguments_.native_mount_approved === true) {
+        const result = await authority.authorize({
+            capability: "native_mount",
+            roots: [],
+            executables: [],
+            environment_names: [],
+            network: "none",
+            mount: true,
+            operation_identity: "inventory_artifact:native_mount",
+        }, "read");
+        if (!result.ok)
+            return err(result.error instanceof PermissionRequiredError
+                ? result.error
+                : new AnalysisProtocolError(result.error.message, {
+                    cause: result.error,
+                }));
+    }
+    return ok(null);
+};
+const runAnalysis = async (path, tool, arguments_, options) => {
+    const { logger, signal, snapshotPath } = options;
     const config = parseConfig(process.env);
     if (!config.ok)
-        return { error: config.error._tag, message: config.error.message };
+        return cliError(config.error);
+    const permissionAuthority = await loadConfiguredPermissionAuthority(config.value);
+    if (!permissionAuthority.ok)
+        return cliError(permissionAuthority.error);
+    const authorized = await authorizeAnalysis(permissionAuthority.value, tool, arguments_, snapshotPath);
+    if (!authorized.ok)
+        return cliError(authorized.error);
+    const unavailable = snapshotUnavailable(snapshotPath, config.value.hopperLoaderArgs);
+    if (unavailable !== undefined)
+        return cliError(unavailable);
     const session = createBinarySession(config.value, logger);
     try {
-        const opened = await session.open(path);
+        const prepared = await prepareSnapshot({
+            path,
+            tool,
+            arguments: arguments_,
+            snapshotPath,
+            policy: config.value.analysisSnapshotFilePolicy,
+            provider: replayProviderFor(session, tool),
+        });
+        if (!prepared.ok)
+            return cliError(prepared.error);
+        if (prepared.value.evidence !== undefined)
+            return prepared.value.evidence;
+        const { snapshot } = prepared.value;
+        const opened = await session.open(path, snapshot === undefined ? { signal } : { signal, snapshot });
         if (!opened.ok)
-            return { error: opened.error._tag, message: opened.error.message };
+            return cliError(opened.error);
+        let output;
+        let evidence;
         if (tool === "binary_overview" ||
             tool === "analyze_function" ||
             tool === "trace_feature") {
-            const result = await new EnhancedTools(session).execute(tool, arguments_);
-            return result.ok
-                ? createEvidence(opened.value, tool === "analyze_function"
+            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)
                     : WORKFLOW_PROVIDER, {
                     operation: tool,
@@ -51,22 +156,98 @@ const runAnalysis = async (path, tool, arguments_, logger) => {
                     result: result.value,
                     confidence: "derived",
                     limitations: ["Derived by an REA composed workflow."],
-                })
-                : { error: result.error._tag, message: result.error.message };
+                });
+                output = evidence;
+            }
         }
-        const result = await session.execute(tool, arguments_);
-        return result.ok
-            ? createEvidence(result.value.subject ?? opened.value, result.value.provider, {
-                operation: tool,
-                parameters: arguments_,
-                result: result.value.result,
-                rawResult: result.value.rawResult,
-                limitations: result.value.limitations,
-                locations: result.value.locations,
-            })
-            : { error: result.error._tag, message: result.error.message };
+        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,
+                    rawResult: result.value.rawResult,
+                    limitations: result.value.limitations,
+                    locations: result.value.locations,
+                });
+                output = evidence;
+            }
+        }
+        if (evidence !== undefined)
+            session.recordEvidence(evidence);
+        if (snapshotPath !== undefined && evidence !== undefined) {
+            const snapshot = session.exportAnalysisSnapshot();
+            if (!snapshot.ok)
+                return cliError(snapshot.error);
+            const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true, config.value.analysisSnapshotFilePolicy);
+            if (!written.ok)
+                return cliError(written.error);
+        }
+        return output;
     }
     finally {
         await session.close();
     }
 };
+const withProcessCancellation = async (suppliedSignal, operation) => {
+    if (suppliedSignal !== undefined)
+        return operation(suppliedSignal);
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.once("SIGINT", cancel);
+    try {
+        return await operation(controller.signal);
+    }
+    finally {
+        process.off("SIGINT", cancel);
+    }
+};
+const prepareSnapshot = async (options) => {
+    const { path, tool, arguments: arguments_, snapshotPath, policy, provider, } = options;
+    if (snapshotPath === undefined || !(await fileExists(snapshotPath)))
+        return ok({});
+    const loaded = await readAnalysisSnapshot(snapshotPath, policy);
+    if (!loaded.ok)
+        return loaded;
+    const target = await parseBinaryTarget(path);
+    if (!target.ok)
+        return target;
+    if (!snapshotMatchesTarget(loaded.value.target, target.value))
+        return err(new EvidenceIntegrityError("Analysis snapshot target does not match the requested binary"));
+    const evidence = snapshotEvidenceForQuery(loaded.value, {
+        target: target.value,
+        operation: tool,
+        parameters: arguments_,
+        provider,
+    });
+    return ok(evidence === undefined
+        ? { snapshot: loaded.value }
+        : { snapshot: loaded.value, evidence });
+};
+const snapshotUnavailable = (snapshotPath, loaderArgs) => snapshotPath !== undefined && loaderArgs.length > 0
+    ? new EvidenceIntegrityError("Analysis snapshots are unavailable with custom Hopper loader arguments")
+    : undefined;
+const replayProviderFor = (session, tool) => tool === "binary_overview" || tool === "trace_feature"
+    ? WORKFLOW_PROVIDER
+    : session.providerIdentity(tool);
+const fileExists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (cause) {
+        if (typeof cause === "object" &&
+            cause !== null &&
+            "code" in cause &&
+            cause.code === "ENOENT")
+            return false;
+        throw cause;
+    }
+};
+const cliError = (error) => ({
+    error: "Analysis failed",
+    ...projectAnalysisError(error),
+});