rea-agents 3.1.0 → 3.2.0

package/dist/domain/functionComparisonResults.js

@@ -1,19 +1,30 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-export const dimensionResult = (input) => ({
-    dimension: input.dimension,
-    status: input.status,
-    left_digest: digest(input.left),
-    right_digest: digest(input.right),
-    left_count: input.leftCount,
-    right_count: input.rightCount,
-    text_delta: input.textDelta,
-    conclusion_kind: input.status === "changed" && input.providersDiffer
-        ? "contradiction"
-        : "derived_relationship",
-    evidence_links: [...input.links],
-    limitations: [...input.limitations],
-});
+export const dimensionResult = (input) => {
+    const context = {
+        dimension: input.dimension,
+        left_digest: digest(input.left),
+        right_digest: digest(input.right),
+        left_count: input.leftCount,
+        right_count: input.rightCount,
+        text_delta: input.textDelta,
+        evidence_links: [...input.links],
+        limitations: [...input.limitations],
+    };
+    if (input.status === "unchanged")
+        return {
+            ...context,
+            status: "unchanged",
+            conclusion_kind: "derived_relationship",
+        };
+    return {
+        ...context,
+        status: "changed",
+        conclusion_kind: input.providersDiffer
+            ? "contradiction"
+            : "derived_relationship",
+    };
+};
 export const unresolvedDimension = (input) => ({
     dimension: input.dimension,
     status: input.status,
@@ -30,7 +41,6 @@ export const overallStatus = (dimensions, match) => {
     if (dimensions.some(({ status }) => status === "truncated"))
         return "truncated";
     if (match === "ambiguous" ||
-        match === "unknown" ||
         dimensions.some(({ status }) => status === "unknown"))
         return "unknown";
     if (match === "mismatched")

package/dist/domain/functionComparisonSchemas.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
+import { evidenceSchema } from "./evidence.js";
 const comparisonStatusSchema = z.enum([
     "unchanged",
-    "added",
-    "removed",
     "changed",
     "truncated",
     "unknown",
@@ -19,44 +18,67 @@ const dimensionNameSchema = z.enum([
 ]);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-/** Strict bounded input for explicit function-to-function comparison. */
+/** Inputs for explicit function-to-function comparison. */
 export const functionComparisonInputSchema = z.strictObject({
-    left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
-    unknown_registry_approved: z.literal(true).optional(),
+    left: evidenceSchema,
+    right: evidenceSchema,
 });
 const textDeltaSchema = z.object({
     added_lines: z.number().int().min(0),
     removed_lines: z.number().int().min(0),
     hunks: z.number().int().min(0),
 });
-const functionDimensionSchema = z.object({
+const functionDimensionContextShape = {
     dimension: dimensionNameSchema,
-    status: comparisonStatusSchema,
-    left_digest: digestSchema.nullable(),
-    right_digest: digestSchema.nullable(),
     left_count: z.number().int().min(0).nullable(),
     right_count: z.number().int().min(0).nullable(),
-    text_delta: textDeltaSchema.nullable(),
-    conclusion_kind: z.enum([
-        "derived_relationship",
-        "contradiction",
-        "unresolved_branch",
-    ]),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(200),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
-});
-/** Deterministic dimension-classified function comparison Evidence payload. */
-export const functionComparisonResultSchema = z.object({
-    status: comparisonStatusSchema,
-    function_match: z.object({
-        status: z.enum(["matched", "mismatched", "ambiguous", "unknown"]),
-        method: z.enum(["explicit", "symbol"]),
+};
+const functionDimensionSchema = z.union([
+    z.object({
+        ...functionDimensionContextShape,
+        status: z.literal("unchanged"),
+        left_digest: digestSchema,
+        right_digest: digestSchema,
+        text_delta: textDeltaSchema.nullable(),
+        conclusion_kind: z.literal("derived_relationship"),
+    }),
+    z.object({
+        ...functionDimensionContextShape,
+        status: z.literal("changed"),
+        left_digest: digestSchema,
+        right_digest: digestSchema,
+        text_delta: textDeltaSchema.nullable(),
+        conclusion_kind: z.enum(["derived_relationship", "contradiction"]),
+    }),
+    z.object({
+        ...functionDimensionContextShape,
+        status: z.enum(["truncated", "unknown"]),
+        left_digest: z.null(),
+        right_digest: z.null(),
+        text_delta: z.null(),
+        conclusion_kind: z.literal("unresolved_branch"),
+    }),
+]);
+const functionMatchSchema = z.union([
+    z.object({
+        status: z.literal("matched"),
+        method: z.literal("symbol"),
         left_name: z.string(),
         right_name: z.string(),
     }),
+    z.object({
+        status: z.enum(["mismatched", "ambiguous"]),
+        method: z.literal("explicit"),
+        left_name: z.string(),
+        right_name: z.string(),
+    }),
+]);
+/** Deterministic dimension-classified function comparison Evidence payload. */
+export const functionComparisonResultSchema = z.object({
+    status: comparisonStatusSchema,
+    function_match: functionMatchSchema,
     left_subject_sha256: digestSchema,
     right_subject_sha256: digestSchema,
     summary: z.object({
@@ -66,12 +88,6 @@ export const functionComparisonResultSchema = z.object({
         unknown: z.number().int().min(0),
     }),
     dimensions: z.array(functionDimensionSchema).length(8),
-    changes: z.object({
-        items: z.array(functionDimensionSchema).max(100),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-    }),
+    changes: z.array(functionDimensionSchema),
     limitations: z.array(z.string()),
 });

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,164 +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
-            ? { complete: true, truncated: false }
-            : { complete: false, truncated: true }),
-    };
-};
-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
-            ? { complete: true, truncated: false }
-            : {
-                complete: false,
-                truncated: scanLimited || !unavailable,
-            }),
-    };
-};
-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

@@ -2,6 +2,7 @@ import { z } from "zod";
 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);
@@ -34,24 +35,6 @@ const segmentSchema = z.object({
     writable: z.boolean().nullable().default(null),
     executable: z.boolean().nullable().default(null),
 });
-const addressedPageFacts = {
-    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),
-};
-const addressedPageSchema = z.discriminatedUnion("has_more", [
-    z.object({
-        ...addressedPageFacts,
-        has_more: z.literal(true),
-        next_offset: z.number().int().min(0),
-    }),
-    z.object({
-        ...addressedPageFacts,
-        has_more: z.literal(false),
-        next_offset: z.null(),
-    }),
-]);
 const unavailableAnalysisFactSchema = z
     .object({ available: z.literal(false), reason: z.string() })
     .strict();
@@ -76,49 +59,11 @@ export const localVariableSchema = z
     provenance: z.string().min(1),
 })
     .strict();
-const boundedSchema = (item) => {
-    const boundedFacts = {
-        items: z.array(item),
-        total: z.number().int().min(0).nullable(),
-        returned: z.number().int().min(0),
-    };
-    return z
-        .discriminatedUnion("truncated", [
-        z.strictObject({
-            ...boundedFacts,
-            truncated: z.literal(false),
-            next_offset: z.null(),
-        }),
-        z.strictObject({
-            ...boundedFacts,
-            truncated: z.literal(true),
-            next_offset: z.number().int().min(0).nullable(),
-        }),
-    ])
-        .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"],
-            });
-        }
-    });
-};
-/** 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();
@@ -166,76 +111,42 @@ export const functionDossierSchema = z
         locals: z.array(localVariableSchema),
     })
         .strict(),
-    pseudocode: z
-        .discriminatedUnion("truncated", [
-        z.strictObject({
-            text: z.string(),
-            total_chars: z.number().int().min(0),
-            returned_chars: z.number().int().min(0),
-            truncated: z.literal(false),
-            next_offset: z.null(),
-        }),
-        z.strictObject({
-            text: z.string(),
-            total_chars: z.number().int().min(0),
-            returned_chars: z.number().int().min(0),
-            truncated: z.literal(true),
-            next_offset: z.number().int().min(0).nullable(),
-        }),
-    ])
-        .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"],
-            });
-        }
-    }),
-    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.nullable().default(null),
+    native_value_flow: nativeValueFlowSchema.nullable().default(null),
     limitations: z.array(z.string()).default([]),
 })
     .strict();
@@ -246,43 +157,19 @@ export const parseFunctionDossier = (value) => {
         ? 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);
@@ -319,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);