rea-agents 3.0.0 → 3.2.0

package/dist/domain/functionDossierEvidence.js

@@ -1,10 +1,5 @@
-import canonicalize from "canonicalize";
-import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
 import { parseEvidence } from "./evidence.js";
 import { functionDossierSchema } from "./hopperValues.js";
-const MAX_PAGES = 100;
-const MAX_ITEMS = 50_000;
-const MAX_PSEUDOCODE_CHARS = 2_000_000;
 const DOSSIER_COLLECTION_FIELDS = [
     "assembly",
     "comments",
@@ -16,159 +11,44 @@ const DOSSIER_COLLECTION_FIELDS = [
     "referenced_names",
     "basic_blocks",
 ];
-/** Parse and assemble up to 100 mutually consistent analyze_function pages. */
+/** Parse one complete analyze_function Evidence record for comparison workflows. */
 export const parseFunctionEvidence = (input) => {
-    const values = Array.isArray(input) ? input : [input];
-    if (values.length === 0 || values.length > MAX_PAGES)
-        throw new TypeError("Function comparison requires 1 to 100 Evidence pages");
-    const pages = values.map(parsePage);
-    assertPageGroup(pages);
-    const first = pages[0];
-    if (first === undefined)
-        throw new TypeError("Function comparison requires Evidence pages");
-    const pseudocode = mergePseudocode(pages);
-    const collections = {
-        assembly: mergeCollection(pages, "assembly"),
-        comments: mergeCollection(pages, "comments"),
-        callers: mergeCollection(pages, "callers"),
-        callees: mergeCollection(pages, "callees"),
-        incoming_references: mergeCollection(pages, "incoming_references"),
-        outgoing_references: mergeCollection(pages, "outgoing_references"),
-        referenced_strings: mergeCollection(pages, "referenced_strings"),
-        referenced_names: mergeCollection(pages, "referenced_names"),
-        basic_blocks: mergeCollection(pages, "basic_blocks"),
-    };
-    return {
-        evidence: pages.map(({ evidence }) => evidence),
-        procedure: first.dossier.procedure,
-        provider: first.evidence.provider,
-        subject: first.evidence.subject,
-        pseudocode,
-        collections,
-        instructionScan: first.dossier.instruction_scan,
-        limitations: [
-            ...new Set(pages.flatMap(({ evidence, dossier }) => [
-                ...evidence.limitations,
-                ...dossier.limitations,
-            ])),
-        ].sort((left, right) => left.localeCompare(right)),
-    };
-};
-const parsePage = (input) => {
     const evidence = parseEvidence(input);
     if (evidence.operation !== "analyze_function")
         throw new TypeError("Function comparison requires analyze_function Evidence");
     if (evidence.subject === null)
         throw new TypeError("Function comparison requires artifact-bound Evidence");
+    const dossier = functionDossierSchema.parse(evidence.normalized_result);
     return {
-        evidence: { ...evidence, subject: evidence.subject },
-        dossier: functionDossierSchema.parse(evidence.normalized_result),
-        parameters: enhancedInputSchemas.analyze_function.parse(evidence.parameters),
+        evidence: [evidence],
+        procedure: dossier.procedure,
+        provider: evidence.provider,
+        subject: evidence.subject,
+        pseudocode: {
+            text: dossier.pseudocode,
+            total: [...dossier.pseudocode].length,
+            complete: true,
+            truncated: false,
+        },
+        collections: {
+            assembly: completeCollection(dossier.assembly),
+            comments: completeCollection(dossier.comments),
+            callers: completeCollection(dossier.callers),
+            callees: completeCollection(dossier.callees),
+            incoming_references: completeCollection(dossier.incoming_references),
+            outgoing_references: completeCollection(dossier.outgoing_references),
+            referenced_strings: completeCollection(dossier.referenced_strings),
+            referenced_names: completeCollection(dossier.referenced_names),
+            basic_blocks: completeCollection(dossier.basic_blocks),
+        },
+        limitations: [
+            ...new Set([...evidence.limitations, ...dossier.limitations]),
+        ].sort((left, right) => left.localeCompare(right)),
     };
 };
-const assertPageGroup = (pages) => {
-    const first = pages[0];
-    if (first === undefined)
-        return;
-    const invariant = pageInvariant(first);
-    for (const page of pages)
-        if (canonicalJson(pageInvariant(page)) !== canonicalJson(invariant))
-            throw new TypeError("Function Evidence pages mix subjects, providers, or immutable analysis controls");
-};
-const pageInvariant = (page) => ({
-    subject: {
-        digest: page.evidence.subject?.digest,
-        format: page.evidence.subject?.format,
-        architecture: page.evidence.subject?.architecture,
-    },
-    provider: page.evidence.provider,
-    procedure: page.dossier.procedure,
-    requested_procedure: page.parameters.procedure,
-    include_assembly: page.parameters.include_assembly,
-    max_instructions: page.parameters.max_instructions,
-    instruction_scan: page.dossier.instruction_scan,
+const completeCollection = (items) => ({
+    items,
+    total: items.length,
+    complete: true,
+    truncated: false,
 });
-const mergePseudocode = (pages) => {
-    const totals = new Set(pages.map(({ dossier }) => dossier.pseudocode.total_chars));
-    if (totals.size !== 1)
-        throw new TypeError("Function pseudocode pages disagree on total length");
-    const total = pages[0]?.dossier.pseudocode.total_chars ?? 0;
-    if (total > MAX_PSEUDOCODE_CHARS)
-        throw new TypeError("Function pseudocode exceeds comparison limit");
-    const characters = new Map();
-    for (const page of pages) {
-        const offset = page.parameters.pseudocode_offset;
-        for (const [index, character] of [
-            ...page.dossier.pseudocode.text,
-        ].entries())
-            mergeIndexed(characters, offset + index, character, "pseudocode");
-        if (characters.size > MAX_PSEUDOCODE_CHARS)
-            throw new TypeError("Function pseudocode exceeds comparison limit");
-    }
-    const complete = hasCompleteRange(characters, total);
-    return {
-        text: orderedValues(characters).join(""),
-        total,
-        complete,
-        truncated: !complete,
-    };
-};
-const mergeCollection = (pages, field) => {
-    const totals = new Set(pages.map(({ dossier }) => dossier[field].total));
-    if (totals.size !== 1)
-        throw new TypeError(`Function ${field} pages disagree on total count`);
-    const total = pages[0]?.dossier[field].total ?? null;
-    if (total !== null && total > MAX_ITEMS)
-        throw new TypeError(`Function ${field} exceeds comparison item limit`);
-    const items = new Map();
-    for (const page of pages) {
-        const offset = collectionOffset(page, field);
-        for (const [index, item] of page.dossier[field].items.entries())
-            mergeIndexed(items, offset + index, item, field);
-        if (items.size > MAX_ITEMS)
-            throw new TypeError(`Function ${field} exceeds comparison item limit`);
-    }
-    const scanLimited = field !== "assembly" && pageDependsOnScan(field)
-        ? pages.some(({ dossier }) => dossier.instruction_scan.truncated)
-        : false;
-    const unavailable = field === "assembly" &&
-        pages.every(({ parameters }) => !parameters.include_assembly);
-    const complete = !scanLimited &&
-        !unavailable &&
-        total !== null &&
-        hasCompleteRange(items, total);
-    return {
-        items: orderedValues(items),
-        total,
-        complete,
-        truncated: scanLimited || (!unavailable && !complete),
-    };
-};
-const collectionOffset = (page, field) => field === "assembly"
-    ? page.parameters.assembly_offset
-    : page.parameters.collection_offset[field];
-const pageDependsOnScan = (field) => field !== "callers" && field !== "callees";
-const mergeIndexed = (output, index, value, field) => {
-    const previous = output.get(index);
-    if (previous !== undefined &&
-        canonicalJson(previous) !== canonicalJson(value))
-        throw new TypeError(`Function ${field} pages overlap with conflicting data`);
-    output.set(index, value);
-};
-const hasCompleteRange = (values, total) => {
-    if (values.size !== total)
-        return false;
-    for (let index = 0; index < total; index += 1)
-        if (!values.has(index))
-            return false;
-    return true;
-};
-const orderedValues = (values) => [...values.entries()]
-    .sort(([left], [right]) => left - right)
-    .map(([, value]) => value);
-const canonicalJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Function Evidence could not be canonicalized");
-    return encoded;
-};

package/dist/domain/hopperStartupFailure.js

@@ -27,7 +27,7 @@ const failures = [
     [
         75,
         "hopper_exited_during_startup",
-        "Hopper exited before the REA bridge was ready. In CI, run rea doctor --provider hopper --detail full --json; if Hopper showed a UI or license prompt, complete it in the runner user session, otherwise close stale Hopper sessions and retry.",
+        "Hopper exited before the REA bridge was ready. In CI, run rea doctor --provider hopper --json; if Hopper showed a UI or license prompt, complete it in the runner user session, otherwise close stale Hopper sessions and retry.",
     ],
     [
         76,

package/dist/domain/hopperValues.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { jsonValueSchema } from "./jsonValue.js";
 import { AnalysisOutputError, HopperProtocolError } from "./errors.js";
 import { err, ok } from "./result.js";
 import { nativeApiBoundarySchema } from "./nativeApiBoundary.js";
+import { nativeValueFlowSchema } from "./nativeValueFlow.js";
 /** Return a bounded byte distance between canonical addresses in one space. */
 export const addressDistance = (start, end) => {
     const left = addressCoordinate(start);
@@ -35,31 +35,6 @@ const segmentSchema = z.object({
     writable: z.boolean().nullable().default(null),
     executable: z.boolean().nullable().default(null),
 });
-const addressedPageSchema = z
-    .object({
-    items: z.array(z.object({ address: z.string(), value: z.string() })),
-    offset: z.number().int().min(0),
-    limit: z.number().int().min(1),
-    total: z.number().int().min(0),
-    next_offset: z.number().int().min(0).nullable(),
-    has_more: z.boolean(),
-})
-    .superRefine((value, context) => {
-    if (value.has_more && value.next_offset === null) {
-        context.addIssue({
-            code: "custom",
-            message: "a page with more results must provide next_offset",
-            path: ["next_offset"],
-        });
-    }
-    if (!value.has_more && value.next_offset !== null) {
-        context.addIssue({
-            code: "custom",
-            message: "a complete page must not provide next_offset",
-            path: ["next_offset"],
-        });
-    }
-});
 const unavailableAnalysisFactSchema = z
     .object({ available: z.literal(false), reason: z.string() })
     .strict();
@@ -84,45 +59,11 @@ export const localVariableSchema = z
     provenance: z.string().min(1),
 })
     .strict();
-const boundedSchema = (item) => z
-    .object({
-    items: z.array(item),
-    total: z.number().int().min(0).nullable(),
-    returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.returned !== value.items.length) {
-        context.addIssue({
-            code: "custom",
-            message: "returned must equal the number of items",
-            path: ["returned"],
-        });
-    }
-    if (value.total !== null && value.total < value.returned) {
-        context.addIssue({
-            code: "custom",
-            message: "total cannot be smaller than returned",
-            path: ["total"],
-        });
-    }
-    if (value.next_offset !== null && !value.truncated) {
-        context.addIssue({
-            code: "custom",
-            message: "a continuation requires truncated output",
-            path: ["next_offset"],
-        });
-    }
-});
-/** Provider-neutral bounded raw-instruction window for one analyzed function. */
+/** Provider-neutral complete raw-instruction list for one analyzed function. */
 export const functionInstructionWindowSchema = z
     .object({
     procedure: procedureIdentitySchema,
-    instructions: boundedSchema(z.string()),
-    instructions_scanned: z.number().int().min(0),
-    instruction_scan_truncated: z.boolean(),
+    instructions: z.array(z.string()),
     limitations: z.array(z.string()),
 })
     .strict();
@@ -170,75 +111,42 @@ export const functionDossierSchema = z
         locals: z.array(localVariableSchema),
     })
         .strict(),
-    pseudocode: z
-        .object({
-        text: z.string(),
-        total_chars: z.number().int().min(0),
-        returned_chars: z.number().int().min(0),
-        truncated: z.boolean(),
-        next_offset: z.number().int().min(0).nullable(),
-    })
-        .strict()
-        .superRefine((value, context) => {
-        if (value.returned_chars !== [...value.text].length) {
-            context.addIssue({
-                code: "custom",
-                message: "returned_chars must equal the text length",
-                path: ["returned_chars"],
-            });
-        }
-        if (value.total_chars < value.returned_chars) {
-            context.addIssue({
-                code: "custom",
-                message: "total_chars cannot be smaller than returned_chars",
-                path: ["total_chars"],
-            });
-        }
-        if (value.next_offset !== null && !value.truncated) {
-            context.addIssue({
-                code: "custom",
-                message: "a continuation requires truncated pseudocode",
-                path: ["next_offset"],
-            });
-        }
-    }),
-    assembly: boundedSchema(z.string()),
-    comments: boundedSchema(z
+    pseudocode: z.string(),
+    assembly: z.array(z.string()),
+    comments: z.array(z
         .object({
         address: z.string(),
         kind: z.enum(["comment", "inline"]),
         text: z.string(),
     })
         .strict()),
-    callers: boundedSchema(procedureIdentitySchema),
-    callees: boundedSchema(procedureIdentitySchema),
-    incoming_references: boundedSchema(referenceEdgeSchema),
-    outgoing_references: boundedSchema(referenceEdgeSchema),
-    referenced_strings: boundedSchema(z
+    callers: z.array(procedureIdentitySchema),
+    callees: z.array(procedureIdentitySchema),
+    incoming_references: z.array(referenceEdgeSchema),
+    outgoing_references: z.array(referenceEdgeSchema),
+    referenced_strings: z.array(z
         .object({
         address: z.string(),
         value: z.string(),
         source_address: z.string(),
     })
         .strict()),
-    referenced_names: boundedSchema(z
+    referenced_names: z.array(z
         .object({
         address: z.string(),
         value: z.string(),
         source_address: z.string(),
     })
         .strict()),
-    basic_blocks: boundedSchema(z
+    basic_blocks: z.array(z
         .object({
         start: z.string(),
         end: z.string(),
         successors: z.array(z.string()),
     })
         .strict()),
-    instruction_scan: z
-        .object({ scanned: z.number().int().min(0), truncated: z.boolean() })
-        .strict(),
-    native_api: nativeApiBoundarySchema.optional(),
+    native_api: nativeApiBoundarySchema.nullable().default(null),
+    native_value_flow: nativeValueFlowSchema.nullable().default(null),
     limitations: z.array(z.string()).default([]),
 })
     .strict();
@@ -246,46 +154,22 @@ export const functionDossierSchema = z
 export const parseFunctionDossier = (value) => {
     const parsed = functionDossierSchema.safeParse(value);
     return parsed.success
-        ? ok(jsonValueSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisOutputError("analyze_function", "provider output did not match the dossier contract", { cause: parsed.error }));
 };
-/** Parse page entries and continuation metadata returned by list operations. */
-export const parseAddressedPage = (value) => {
-    const parsed = addressedPageSchema.safeParse(value);
-    return parsed.success
-        ? ok({
-            items: parsed.data.items.map(({ address, value: name }) => ({
-                address,
-                name,
-            })),
-            nextOffset: parsed.data.next_offset,
-            hasMore: parsed.data.has_more,
-        })
-        : invalid("addressed page", parsed.error);
-};
 /** Parse Hopper's direct or wrapped procedure map into stable entries. */
 export const parseProcedures = (value) => {
-    const page = parseAddressedPage(value);
-    if (page.ok)
-        return ok(page.value.items);
     const parsed = procedureMapSchema.safeParse(unwrapProperty(value, "procedures"));
     return parsed.success
         ? ok(Object.entries(parsed.data).map(([address, name]) => ({
             address,
             name,
         })))
-        : page;
+        : invalid("procedure map", parsed.error);
 };
 /** Parse Hopper's direct or wrapped list of address/name records. */
 export const parseNames = (value) => {
     const unwrapped = unwrapProperty(value, "names");
-    const page = z
-        .object({
-        items: z.array(z.object({ address: z.string(), value: z.string() })),
-    })
-        .safeParse(unwrapped);
-    if (page.success)
-        return ok(page.data.items.map(({ address, value: name }) => ({ address, name })));
     const records = addressedNamesSchema.safeParse(unwrapped);
     if (records.success)
         return ok(records.data);
@@ -322,14 +206,6 @@ export const parseDocuments = (value) => {
 /** Parse a direct or wrapped list when only its cardinality is required. */
 export const parseListCount = (value, property) => {
     const unwrapped = unwrapProperty(value, property);
-    const pageTotal = z
-        .object({ total: z.number().int().min(0) })
-        .safeParse(unwrapped);
-    if (pageTotal.success)
-        return ok(pageTotal.data.total);
-    const page = z.object({ items: z.array(z.unknown()) }).safeParse(unwrapped);
-    if (page.success)
-        return ok(page.data.items.length);
     const list = z.array(z.unknown()).safeParse(unwrapped);
     if (list.success)
         return ok(list.data.length);

package/dist/domain/inputIssueProjection.js

@@ -2,6 +2,8 @@
 export const projectInputIssues = (issues, input) => issues.flatMap((issue) => projectIssue(issue, input));
 const projectIssue = (issue, input) => {
     const path = issue.path.flatMap((part) => typeof part === "string" || typeof part === "number" ? [part] : []);
+    if (issue.code === "invalid_union")
+        return issue.errors.flatMap((branch) => branch.flatMap((branchIssue) => projectIssue(branchIssue, input)));
     if (issue.code === "unrecognized_keys")
         return issue.keys.map((key) => ({
             path: [...path, key],
@@ -44,7 +46,8 @@ const valueAtPath = (input, path) => {
     for (const part of path) {
         if (typeof current !== "object" || current === null)
             return undefined;
-        current = current[part];
+        const next = Reflect.get(current, part);
+        current = next;
     }
     return current;
 };