rea-agents 6.0.0 → 6.1.0

package/dist/application/ClientRegistrationIdentity.js

@@ -1,6 +1,26 @@
 import { basename, isAbsolute, resolve } from "node:path";
 import { valid } from "semver";
 import { PRODUCT_IDENTITY } from "../identity.js";
+/** Resolve a pinned npx launcher that stdio clients can spawn on the host. */
+export const npxRegistrationCommand = (platform = process.platform) => {
+    const command = [
+        "npx",
+        "-y",
+        PRODUCT_IDENTITY.registrationPackageSpecifier,
+        "mcp",
+    ];
+    return platform === "win32" ? ["cmd.exe", "/d", "/c", ...command] : command;
+};
+const unwrapNpxCommand = (command) => {
+    const executable = command[0]?.toLowerCase();
+    if (executable !== "cmd" && executable !== "cmd.exe")
+        return command;
+    if (command[1]?.toLowerCase() === "/c")
+        return command.slice(2);
+    if (command[1]?.toLowerCase() === "/d" && command[2]?.toLowerCase() === "/c")
+        return command.slice(3);
+    return [];
+};
 /** Check that one parsed command points to REA's MCP entry point. */
 export const isOwnedClientRegistrationCommand = (command, currentCommandPath = resolve(process.argv[1] ?? "unknown")) => {
     if (command.length === 3 &&
@@ -16,12 +36,13 @@ export const isOwnedClientRegistrationCommand = (command, currentCommandPath = r
             resolve(executable) === currentCommandPath)
             return true;
     }
-    if (command.length !== 4 ||
-        command[0] !== "npx" ||
-        command[1] !== "-y" ||
-        command[3] !== "mcp")
+    const npxCommand = unwrapNpxCommand(command);
+    if (npxCommand.length !== 4 ||
+        npxCommand[0] !== "npx" ||
+        npxCommand[1] !== "-y" ||
+        npxCommand[3] !== "mcp")
         return false;
-    const packageReference = command[2] ?? "";
+    const packageReference = npxCommand[2] ?? "";
     if (packageReference === PRODUCT_IDENTITY.packageName ||
         packageReference === PRODUCT_IDENTITY.packageSpecifier ||
         packageReference === PRODUCT_IDENTITY.registrationPackageSpecifier)

package/dist/application/ClientRegistrationStatus.js

@@ -1,11 +1,11 @@
-import { effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { effectiveClientServer, grokServerListedDisabled, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
-import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
-import { supportedClients } from "./SupportedClients.js";
+import { isOwnedClientRegistrationCommand, npxRegistrationCommand, } from "./ClientRegistrationIdentity.js";
+import { manualRegistrationRemediation, supportedClients, } from "./SupportedClients.js";
 const registrationSchema = z
     .object({
     command: z.string().min(1),
@@ -28,15 +28,30 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             CLAUDE_CONFIG_DIR: options.environment.CLAUDE_CONFIG_DIR,
             CODEX_HOME: options.environment.CODEX_HOME,
             COPILOT_HOME: options.environment.COPILOT_HOME,
+            GROK_HOME: options.environment.GROK_HOME,
             OPENCODE_CONFIG: options.environment.OPENCODE_CONFIG,
+            SAND_DATA_ROOT: options.environment.SAND_DATA_ROOT,
             XDG_CONFIG_HOME: options.environment.XDG_CONFIG_HOME,
         })) {
-        if (client.format === "unsupported" ||
-            (!(await exists(client.markerPath)) && !(await exists(client.configPath))))
+        if (!(await exists(client.markerPath)) &&
+            !(await exists(client.configPath)))
             continue;
+        const manualRemediation = manualRegistrationRemediation(client.name);
+        if (client.format === "unsupported") {
+            if (manualRemediation !== undefined)
+                statuses.push({
+                    client: client.name,
+                    config_path: client.markerPath ?? client.configPath,
+                    command: [],
+                    state: "manual",
+                    remediation: manualRemediation,
+                });
+            continue;
+        }
         try {
             const content = await readFile(client.configPath, "utf8");
-            const raw = effectiveClientServer(parseClientConfiguration(content, client.format), PRODUCT_IDENTITY.mcpServerKey);
+            const parsed = parseClientConfiguration(content, client.format);
+            const raw = effectiveClientServer(parsed, PRODUCT_IDENTITY.mcpServerKey);
             if (raw === undefined) {
                 statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
@@ -46,7 +61,9 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
                 registration.command,
                 ...registration.args,
             ];
-            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath)
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath, options.platform ?? process.platform) &&
+                !(client.format === "grok" &&
+                    grokServerListedDisabled(parsed.document, PRODUCT_IDENTITY.mcpServerKey))
                 ? "aligned"
                 : "stale"));
         }
@@ -56,13 +73,13 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
     }
     return statuses.sort((left, right) => left.client.localeCompare(right.client));
 };
-const registrationAligned = (registration, client, currentCommandPath) => {
+const registrationAligned = (registration, client, currentCommandPath, platform) => {
     const command = [registration.command, ...registration.args];
     if (registration.disabled === true || registration.enabled === false)
         return false;
     if (!isOwnedClientRegistrationCommand(command, currentCommandPath))
         return false;
-    if (client.name === "codex" &&
+    if ((client.name === "codex" || client.name === "grok_build") &&
         registration.startup_timeout_sec !==
             MCP_STARTUP_POLICY.codexStartupTimeoutSeconds)
         return false;
@@ -79,11 +96,9 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         resolve(command[0] ?? "") === resolve(process.execPath) &&
         resolve(command[1] ?? "") === currentCommandPath)
         return true;
-    if (command.length === 4 &&
-        command[0] === "npx" &&
-        command[1] === "-y" &&
-        command[2] === PRODUCT_IDENTITY.registrationPackageSpecifier &&
-        command[3] === "mcp")
+    const npxCommand = npxRegistrationCommand(platform);
+    if (command.length === npxCommand.length &&
+        command.every((argument, index) => argument === npxCommand[index]))
         return true;
     return (command.length === 2 &&
         command[1] === "mcp" &&

package/dist/application/DirectAnalysis.js

@@ -11,9 +11,9 @@ import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./binary/AnalysisSnapshotFiles.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
-import { analysisProfileSchema, committedProviderSchema, } from "../domain/analysisProfile.js";
 import { err, ok } from "../domain/result.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
+import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "./WorkflowEvidence.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 /**
  * Open one binary, execute one tool, and always release provider resources.
@@ -142,38 +142,32 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
             signal,
             evidenceProfile,
         });
-        if (evidence !== undefined)
-            session.recordEvidence(evidence);
+        if (evidence !== undefined) {
+            const recorded = session.recordEvidence(evidence);
+            if (!recorded.ok)
+                return cliError(recorded.error);
+            if (isWorkflowEvidenceTool(tool)) {
+                const unknowns = recordWorkflowUnknowns({
+                    name: tool,
+                    result: evidence.normalized_result,
+                    evidenceId: evidence.evidence_id,
+                    recordUnknown: (unknown) => session.recordUnknown(unknown),
+                });
+                if (!unknowns.ok)
+                    return cliError(unknowns.error);
+            }
+        }
         if (isWorkflowEvidenceTool(tool) &&
             tool !== "trace_native_ui_action" &&
             snapshotPath !== undefined &&
             evidence !== undefined &&
-            "analysis_profile" in evidence &&
             session.allowsSnapshotReplay(tool)) {
-            const recorded = session.recordWorkflowSnapshot({
-                operation: tool,
-                parameters: arguments_,
-                execution: {
-                    result: evidence.normalized_result,
-                    rawResult: evidence.raw_result,
-                    provider: committedProviderSchema.parse(evidence.provider),
-                    analysisProfile: analysisProfileSchema.parse(evidence.analysis_profile),
-                    limitations: evidence.limitations,
-                    locations: evidence.locations,
-                    subject: evidence.subject === null
-                        ? null
-                        : {
-                            path: evidence.subject.local_path,
-                            sha256: evidence.subject.digest.sha256,
-                            format: evidence.subject.format,
-                            ...(evidence.subject.architecture === null
-                                ? {}
-                                : { architecture: evidence.subject.architecture }),
-                        },
-                },
-            });
-            if (!recorded.ok)
-                return cliError(recorded.error);
+            const workflowRecord = workflowSnapshotRecord(evidence, tool);
+            if (workflowRecord !== undefined) {
+                const recorded = session.recordWorkflowSnapshot(workflowRecord);
+                if (!recorded.ok)
+                    return cliError(recorded.error);
+            }
         }
         if (tool !== "trace_native_ui_action" &&
             snapshotPath !== undefined &&
@@ -208,15 +202,12 @@ const executeAnalysisTool = async (input) => {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
             return { output: cliError(result.error) };
-        const evidence = createEvidence(input.openedTarget, REA_WORKFLOW_PROVIDER, {
+        const evidence = createWorkflowEvidence({
+            target: input.openedTarget,
             operation: tool,
             parameters: input.arguments,
             result: result.value,
-            ...(evidenceProfile === undefined
-                ? {}
-                : { analysisProfile: evidenceProfile }),
-            confidence: "derived",
-            limitations: ["Derived by an REA composed workflow."],
+            upstreamProfile: evidenceProfile,
         });
         return { output: evidence, evidence };
     }
@@ -280,7 +271,7 @@ const analysisProfileForRoute = (route, tool) => {
     if (profile === null || profile === undefined)
         return undefined;
     if (isWorkflowEvidenceTool(tool))
-        return workflowAnalysisProfile(profile);
+        return workflowAnalysisProfile(profile, tool);
     const provider = providerIdentityForRoute(route, tool);
     return provider.id === profile.provider.id ? profile : undefined;
 };
@@ -294,8 +285,7 @@ const providerIdentityForRoute = (route, operation) => {
 const analysisProfileForEvidence = (session, tool) => {
     if (!isWorkflowEvidenceTool(tool))
         return session.analysisProfile(tool);
-    const upstream = session.analysisProfile();
-    return upstream === undefined ? undefined : workflowAnalysisProfile(upstream);
+    return session.analysisProfile();
 };
 const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
     tool === "inspect_native_api" ||

package/dist/application/Doctor.js

@@ -7,6 +7,7 @@ import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
 import { probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
+import { canonicalSkillNeedsInstall } from "./SetupSkill.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
 import { PRODUCT_IDENTITY, SDK_IDENTITY } from "../identity.js";
 import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
@@ -61,7 +62,7 @@ const collectDoctorIdentity = async (host) => {
         checks: [
             ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
             ...registrations
-                .filter((registration) => registration.state !== "aligned")
+                .filter((registration) => registration.state !== "aligned" && registration.state !== "manual")
                 .map(registrationCheck),
         ],
         value: {
@@ -96,7 +97,7 @@ const collectDoctorIdentity = async (host) => {
 };
 const skillIdentityAligned = (identity) => identity?.version === PRODUCT_IDENTITY.skillVersion &&
     identity.toolCount === CATALOG_IDENTITY.counts.mcp_tools &&
-    identity.catalogDigest === CATALOG_IDENTITY.digests.combined_sha256;
+    identity.canonical;
 const skillIdentityCheck = (identity) => ({
     name: "skill:identity",
     ok: false,
@@ -281,6 +282,7 @@ const installedSkillIdentity = async (home) => {
         const content = await readInstalledSkill(home);
         const countText = /^\s{2}tool_count:\s*(\d+)\s*$/mu.exec(content)?.[1];
         return {
+            canonical: !(await canonicalSkillNeedsInstall(home)),
             version: /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(content)?.[1] ?? null,
             toolCount: countText === undefined ? null : Number.parseInt(countText, 10),
             catalogDigest: /^\s{2}catalog_digest:\s*"([a-f0-9]{64})"\s*$/mu.exec(content)?.[1] ??

package/dist/application/DoctorScope.js

@@ -1,4 +1,5 @@
 import { uniqueSorted } from "../domain/canonicalOrdering.js";
+import { manualRegistrationRemediation } from "./SupportedClients.js";
 /** Normalize a caller-selected doctor readiness boundary. */
 export const normalizeDoctorScope = (requested, target) => ({
     mode: requested === undefined ? "audit-wide" : "explicit",
@@ -62,22 +63,33 @@ const selectedProviderChecksFor = (providerId, checks, providers) => {
         },
     ];
 };
-const selectedRegistrationCheck = (client, status) => status === undefined
-    ? {
-        name: `registration:${client}`,
-        ok: false,
-        classification: "config_drift",
-        detail: `Requested client ${client} was not detected.`,
-        remediation: `Install or select ${client}, then run rea setup --client ${client}.`,
-    }
-    : status.state === "aligned"
+const selectedRegistrationCheck = (client, status) => {
+    const manual = manualRegistrationRemediation(client);
+    if (status === undefined && manual !== undefined)
+        return {
+            name: `registration:${client}`,
+            ok: false,
+            classification: "config_drift",
+            detail: `${client} is not registered through a local configuration file.`,
+            remediation: manual,
+        };
+    return status === undefined
         ? {
             name: `registration:${client}`,
-            ok: true,
-            classification: "healthy",
-            detail: status.config_path,
+            ok: false,
+            classification: "config_drift",
+            detail: `Requested client ${client} was not detected.`,
+            remediation: `Install or select ${client}, then run rea setup --client ${client}.`,
         }
-        : registrationCheck(status);
+        : status.state === "aligned"
+            ? {
+                name: `registration:${client}`,
+                ok: true,
+                classification: "healthy",
+                detail: status.config_path,
+            }
+            : registrationCheck(status);
+};
 const registrationCheck = (status) => ({
     name: `registration:${status.client}`,
     ok: false,

package/dist/application/EnhancedLiteralTracing.js

@@ -28,32 +28,29 @@ export const traceLiteralFeature = async (call, input, signal) => {
 };
 const literalMatches = async (call, input, sources, signal) => {
     const matches = [];
-    const needles = [...new Set(input.query.trim().split(/\s+/u))];
     const matched = new Set();
-    for (const needle of needles) {
-        for (const [tool, type] of sources) {
-            const result = await call(tool, {
-                pattern: needle,
-                mode: "literal",
-                case_sensitive: input.case_sensitive,
-            }, signal);
-            if (!result.ok)
-                return result;
-            const items = z
-                .array(z.object({ address: z.string(), value: z.string() }))
-                .safeParse(result.value);
-            if (!items.success)
-                return err(new AnalysisOutputError(tool, "provider returned an invalid search result"));
-            addPageMatches({
-                items: items.data.map(({ address, value: name }) => ({
-                    address,
-                    name,
-                })),
-                type,
-                matches,
-                matched,
-            });
-        }
+    for (const [tool, type] of sources) {
+        const result = await call(tool, {
+            pattern: input.query,
+            mode: "literal",
+            case_sensitive: input.case_sensitive,
+        }, signal);
+        if (!result.ok)
+            return result;
+        const items = z
+            .array(z.object({ address: z.string(), value: z.string() }))
+            .safeParse(result.value);
+        if (!items.success)
+            return err(new AnalysisOutputError(tool, "provider returned an invalid search result"));
+        addPageMatches({
+            items: items.data.map(({ address, value: name }) => ({
+                address,
+                name,
+            })),
+            type,
+            matches,
+            matched,
+        });
     }
     return ok({ matches });
 };

package/dist/application/EnhancedTools.js

@@ -3,7 +3,7 @@ import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
 import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import {} from "../domain/analysisErrorBase.js";
-import { addressDistance, functionDossierSchema, parseDocuments, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
+import { addressDistance, functionDossierSchema, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
 import { err, ok } from "../domain/result.js";
 import { categorizeSwiftTypes, discoverObjcClasses, discoverObjcProtocols, } from "../domain/symbolAnalysis.js";
 import { inspectNativeDispatch } from "./native/NativeDispatchMetadataInspection.js";
@@ -11,7 +11,9 @@ import { traceNativeValues } from "./native/NativeValueTrace.js";
 import { traceNativeUiAction } from "./native/NativeUiActionTrace.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { invalidEnhancedInput, } from "./EnhancedToolTypes.js";
+import { resolveAnalysisDocument } from "./AnalysisDocument.js";
 import { traceCallPath } from "./CallPathTracing.js";
+import { resolveProcedureAddress } from "./ProcedureAddressResolution.js";
 import { traceLiteralFeature } from "./EnhancedLiteralTracing.js";
 import { projectNativeApiInspection } from "./native/NativeApiInspection.js";
 /**
@@ -203,9 +205,12 @@ export class EnhancedTools {
     async #callGraph(input, signal) {
         const relation = input.direction === "forward" ? "callees" : "callers";
         const tool = input.direction === "forward" ? "procedure_callees" : "procedure_callers";
-        const discovered = new Set([input.address]);
+        const resolved = await resolveProcedureAddress(this.#call.bind(this), input.address, signal);
+        if (!resolved.ok)
+            return resolved;
+        const discovered = new Set([resolved.value]);
         const queue = [
-            { address: input.address, depth: 0 },
+            { address: resolved.value, depth: 0 },
         ];
         let queueIndex = 0;
         const graph = {};
@@ -274,16 +279,16 @@ export class EnhancedTools {
         });
     }
     async #binaryOverview(signal) {
-        const [segmentsResult, documentsResult, proceduresResult, stringsResult] = await Promise.all([
+        const document = await resolveAnalysisDocument(this.analysis, undefined, signal);
+        if (!document.ok)
+            return document;
+        const [segmentsResult, proceduresResult, stringsResult] = await Promise.all([
             this.#call("list_segments", {}, signal),
-            this.#call("list_documents", {}, signal),
             this.#call("list_procedures", {}, signal),
             this.#call("list_strings", {}, signal),
         ]);
         if (!segmentsResult.ok)
             return segmentsResult;
-        if (!documentsResult.ok)
-            return documentsResult;
         if (!proceduresResult.ok)
             return proceduresResult;
         if (!stringsResult.ok)
@@ -291,9 +296,6 @@ export class EnhancedTools {
         const segments = parseSegments(segmentsResult.value);
         if (!segments.ok)
             return segments;
-        const documents = parseDocuments(documentsResult.value);
-        if (!documents.ok)
-            return documents;
         const procedureCount = parseListCount(proceduresResult.value, "procedures");
         if (!procedureCount.ok)
             return procedureCount;
@@ -301,7 +303,7 @@ export class EnhancedTools {
         if (!stringCount.ok)
             return stringCount;
         return ok({
-            document: documents.value[0] ?? "unknown",
+            document: document.value,
             segments: segments.value.map(({ name, start, end }) => ({
                 name,
                 start,

package/dist/application/EvidenceBundleFiles.js

@@ -1,37 +1,49 @@
-import { parseEvidenceBundle, serializeEvidenceBundle, } from "../domain/evidenceBundle.js";
+import { describeEvidenceBundleFailure, describeValidationFailure, parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { EvidenceFileError, EvidenceIntegrityError, } from "../domain/evidenceErrors.js";
 import { err, ok } from "../domain/result.js";
 import { parseProcessCapture } from "../domain/process/processCapture.js";
-import { readJsonFile, writeTextFile } from "./JsonFiles.js";
+import { bufferedJsonParts, canonicalJsonParts, } from "../domain/jsonSerialization.js";
+import { readJsonFile, writeTextParts } from "./JsonFiles.js";
 /** Read and validate an evidence bundle at the caller-supplied path. */
 export const readEvidenceBundle = async (path) => {
     const loaded = await readJsonFile(path);
     if (!loaded.ok)
         return loaded;
+    let bundle;
     try {
-        const bundle = parseEvidenceBundle(loaded.value);
-        for (const record of bundle.records) {
-            if (record.predicate_type === "rea.process-capture")
-                parseProcessCapture(record.normalized_result);
-        }
-        return ok(bundle);
+        bundle = parseEvidenceBundle(loaded.value);
     }
     catch (cause) {
         return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
             cause,
+            userMessage: describeEvidenceBundleFailure(loaded.value, cause),
         }));
     }
+    for (const record of bundle.records) {
+        if (record.predicate_type !== "rea.process-capture")
+            continue;
+        try {
+            parseProcessCapture(record.normalized_result);
+        }
+        catch (cause) {
+            return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
+                cause,
+                userMessage: `Process capture record ${record.evidence_id} has an invalid normalized_result (${describeValidationFailure(cause)}). Recreate or re-export the bundle, then try again.`,
+            }));
+        }
+    }
+    return ok(bundle);
 };
 /** Atomically write deterministic evidence JSON at the caller-supplied path. */
 export const writeEvidenceBundle = async (bundle, path, overwrite) => {
-    let encoded;
+    let checked;
     try {
-        encoded = serializeEvidenceBundle(bundle);
+        checked = parseEvidenceBundle(bundle);
     }
     catch (cause) {
         return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
             cause,
         }));
     }
-    return writeTextFile(encoded, path, overwrite);
+    return writeTextParts(bufferedJsonParts(canonicalJsonParts(checked)), path, overwrite);
 };

package/dist/application/FunctionAnalysisEvidence.js

@@ -1,15 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
-import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { createEvidence } from "../domain/evidence.js";
 import { parseFunctionDossier } from "../domain/hopperValues.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 /** Preserve the provider's observations when presenting a validated function dossier. */
 export const executeFunctionAnalysisEvidence = async (analysis, parameters, target, options) => {
     const input = toolContract("analyze_function").inputSchema.safeParse(parameters);
     if (!input.success)
-        return err(new AnalysisInputError("analyze_function", { cause: input.error }, projectInputIssues(input.error.issues, parameters)));
+        return err(analysisInputErrorFromIssues("analyze_function", input.error.issues, parameters, { cause: input.error }));
     const arguments_ = jsonObjectSchema.parse(input.data);
     const execution = await analysis.execute("analyze_function", arguments_, options);
     if (!execution.ok)

package/dist/application/InventoryProjectionEvidence.js

@@ -1,14 +1,15 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
 import {} from "../domain/analysisErrorBase.js";
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
+import { requestInputError, workflowInputError } from "./workflowInputError.js";
 /** Parse one inventory projection and wrap its deterministic result in Evidence. */
 export const projectInventoryEvidence = (options) => {
     const parsed = options.schema.safeParse(options.rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(options.operation, { cause: parsed.error }));
+        return err(requestInputError(options.operation, parsed.error, options.rawInput));
     try {
         const result = options.project(parsed.data);
         const first = parsed.data.inventory_evidence[0];
@@ -38,7 +39,7 @@ export const projectInventoryEvidence = (options) => {
     }
     catch (cause) {
         return err(cause instanceof TypeError || cause instanceof z.ZodError
-            ? new AnalysisInputError(options.operation, { cause })
+            ? workflowInputError(options.operation, cause)
             : new AnalysisProtocolError(options.protocolError, { cause }));
     }
 };

package/dist/application/InvestigationProviders.js

@@ -5,9 +5,10 @@ export const REA_WORKFLOW_PROVIDER = {
     name: "REA composed investigation workflow",
     version: "1",
 };
-/** Commit a workflow result to the exact upstream deep-analysis profile. */
-export const workflowAnalysisProfile = (upstream) => createAnalysisProfile(REA_WORKFLOW_PROVIDER, {
+/** Commit a workflow result to its upstream profile and applicable semantic revision. */
+export const workflowAnalysisProfile = (upstream, operation) => createAnalysisProfile(REA_WORKFLOW_PROVIDER, {
     upstream_analysis_profile: upstream,
+    ...(operation === "binary_overview" ? { workflow_revision: 2 } : {}),
 });
 /** Provider identity for deterministic artifact inventories. */
 export const ARTIFACT_GRAPH_PROVIDER = {