rea-agents 3.0.0 → 3.2.0

package/dist/domain/eventProcessTree.js

@@ -59,7 +59,7 @@ export const processTreeReconstructionSchema = z.strictObject({
     /** Root PID of the process tree. */
     root_pid: z.number().int().positive(),
     /** All reconstructed process nodes. */
-    processes: z.array(processNodeSchema).min(0).max(10_000),
+    processes: z.array(processNodeSchema).min(0),
     /** Events that were consumed. */
     events_consumed: z.number().int().nonnegative(),
     /** Events that could not be matched. */
@@ -71,89 +71,90 @@ export const processTreeReconstructionSchema = z.strictObject({
     /** Whether any reparenting was detected. */
     has_reparenting: z.boolean().default(false),
 });
+const applyProcessTreeEvent = (event, state) => {
+    let node = state.nodes.get(event.pid);
+    switch (event.type) {
+        case "spawn": {
+            if (!node) {
+                node = {
+                    pid: event.pid,
+                    ppid: event.ppid,
+                    process_name: event.process_name,
+                    executable: event.executable,
+                    arguments: event.arguments,
+                    children: [],
+                    spawn_time_ms: event.at_ms,
+                    exit_time_ms: null,
+                    exit_code: null,
+                    is_re_exec: false,
+                    is_reparented: false,
+                    previous_ppid: null,
+                };
+                state.nodes.set(event.pid, node);
+            }
+            if (event.ppid !== null) {
+                const parentChildren = state.children.get(event.ppid) ?? [];
+                parentChildren.push(event.pid);
+                state.children.set(event.ppid, parentChildren);
+            }
+            break;
+        }
+        case "exit":
+            if (node) {
+                node.exit_time_ms = event.at_ms;
+                node.exit_code = event.exit_code;
+                if (node.spawn_time_ms !== null &&
+                    event.at_ms - node.spawn_time_ms < 100)
+                    state.shortLivedDescendants++;
+            }
+            else
+                state.eventsUnmatched++;
+            break;
+        case "re_exec":
+            if (node) {
+                node.is_re_exec = true;
+                node.executable = event.executable ?? node.executable;
+                node.arguments = event.arguments;
+                state.hasReExec = true;
+            }
+            else
+                state.eventsUnmatched++;
+            break;
+        case "reparent":
+            if (node) {
+                node.previous_ppid = node.ppid;
+                node.ppid = event.ppid;
+                node.is_reparented = true;
+                state.hasReparenting = true;
+            }
+            else
+                state.eventsUnmatched++;
+            break;
+        case "signal":
+        case "name_change":
+        case "thread_create":
+        case "thread_exit":
+            // These events are recorded but don't modify the tree structure.
+            break;
+    }
+};
 /** Reconstruct a process tree from event-backed capture. */
 export function reconstructProcessTree(events, rootPid) {
     const nodes = new Map();
     const children = new Map();
     let eventsConsumed = 0;
-    let eventsUnmatched = 0;
-    let hasReExec = false;
-    let hasReparenting = false;
-    let shortLivedDescendants = 0;
+    const state = {
+        nodes,
+        children,
+        eventsUnmatched: 0,
+        hasReExec: false,
+        hasReparenting: false,
+        shortLivedDescendants: 0,
+    };
     const sorted = [...events].sort((a, b) => a.at_ms - b.at_ms);
     for (const event of sorted) {
         eventsConsumed++;
-        let node = nodes.get(event.pid);
-        switch (event.type) {
-            case "spawn": {
-                if (!node) {
-                    node = {
-                        pid: event.pid,
-                        ppid: event.ppid,
-                        process_name: event.process_name,
-                        executable: event.executable,
-                        arguments: event.arguments,
-                        children: [],
-                        spawn_time_ms: event.at_ms,
-                        exit_time_ms: null,
-                        exit_code: null,
-                        is_re_exec: false,
-                        is_reparented: false,
-                        previous_ppid: null,
-                    };
-                    nodes.set(event.pid, node);
-                }
-                if (event.ppid !== null) {
-                    const parentChildren = children.get(event.ppid) ?? [];
-                    parentChildren.push(event.pid);
-                    children.set(event.ppid, parentChildren);
-                }
-                break;
-            }
-            case "exit": {
-                if (node) {
-                    node.exit_time_ms = event.at_ms;
-                    node.exit_code = event.exit_code;
-                    if (node.spawn_time_ms !== null &&
-                        event.at_ms - node.spawn_time_ms < 100)
-                        shortLivedDescendants++;
-                }
-                else {
-                    eventsUnmatched++;
-                }
-                break;
-            }
-            case "re_exec": {
-                if (node) {
-                    node.is_re_exec = true;
-                    node.executable = event.executable ?? node.executable;
-                    node.arguments = event.arguments;
-                    hasReExec = true;
-                }
-                else {
-                    eventsUnmatched++;
-                }
-                break;
-            }
-            case "reparent": {
-                if (node) {
-                    node.previous_ppid = node.ppid;
-                    node.ppid = event.ppid;
-                    node.is_reparented = true;
-                    hasReparenting = true;
-                }
-                else {
-                    eventsUnmatched++;
-                }
-                break;
-            }
-            case "signal":
-            case "name_change":
-            case "thread_create":
-            case "thread_exit":
-                // These events are recorded but don't modify the tree structure
-                break;
-        }
+        applyProcessTreeEvent(event, state);
     }
     // Attach children to nodes
     for (const [pid, childPids] of children) {
@@ -165,10 +166,10 @@ export function reconstructProcessTree(events, rootPid) {
         root_pid: rootPid,
         processes: [...nodes.values()],
         events_consumed: eventsConsumed,
-        events_unmatched: eventsUnmatched,
-        short_lived_descendants: shortLivedDescendants,
-        has_re_exec: hasReExec,
-        has_reparenting: hasReparenting,
+        events_unmatched: state.eventsUnmatched,
+        short_lived_descendants: state.shortLivedDescendants,
+        has_re_exec: state.hasReExec,
+        has_reparenting: state.hasReparenting,
     };
 }
 /** Get all descendant PIDs of a given root PID. */
@@ -177,8 +178,10 @@ export function getDescendants(processes, rootPid) {
     const visited = new Set();
     const result = [];
     const queue = [rootPid];
-    while (queue.length > 0) {
-        const pid = queue.shift();
+    for (let head = 0; head < queue.length; head += 1) {
+        const pid = queue[head];
+        if (pid === undefined)
+            continue;
         if (visited.has(pid))
             continue;
         visited.add(pid);
@@ -201,14 +204,22 @@ export function containsProcess(processes, pid) {
 /** Get the maximum tree depth from the root. */
 export function maxTreeDepth(processes, rootPid) {
     const byPid = new Map(processes.map((p) => [p.pid, p]));
-    function depth(pid, visited) {
-        if (visited.has(pid))
-            return 0;
-        visited.add(pid);
-        const node = byPid.get(pid);
+    const pending = [{ pid: rootPid, depth: 0 }];
+    const visited = new Set();
+    let maximumDepth = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current || visited.has(current.pid))
+            continue;
+        visited.add(current.pid);
+        const node = byPid.get(current.pid);
         if (!node || node.children.length === 0)
-            return 0;
-        return 1 + Math.max(...node.children.map((c) => depth(c, visited)));
+            continue;
+        const childDepth = current.depth + 1;
+        maximumDepth = Math.max(maximumDepth, childDepth);
+        for (const childPid of node.children)
+            if (!visited.has(childPid))
+                pending.push({ pid: childPid, depth: childDepth });
     }
-    return depth(rootPid, new Set());
+    return maximumDepth;
 }

package/dist/domain/evidence.js

@@ -72,7 +72,6 @@ const executionEnvironmentSchema = z.object({
 });
 const evidenceBaseSchema = z
     .object({
-    schema_version: z.literal(2),
     evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
     subject: subjectSchema.nullable(),
     provider: providerSchema,
@@ -124,7 +123,6 @@ const canonicalJson = (value) => {
     return serialized;
 };
 const semanticProjection = (evidence) => ({
-    schema_version: evidence.schema_version,
     subject: evidence.subject === null
         ? null
         : {
@@ -152,18 +150,13 @@ const semanticProjection = (evidence) => ({
 const computeEvidenceId = (evidence) => `ev_${sha256(canonicalJson(semanticProjection(evidence)))}`;
 /** Parse evidence and reject a syntactically valid but tampered semantic ID. */
 export const parseEvidence = (input) => {
-    if (typeof input === "object" &&
-        input !== null &&
-        "schema_version" in input &&
-        input.schema_version !== 2)
-        throw new TypeError(`Unsupported evidence schema_version ${String(input.schema_version)}; Evidence v1 is not accepted. Produce Evidence v2.`);
     const evidence = evidenceRecordSchema.parse(input);
     const { evidence_id: evidenceId, ...withoutId } = evidence;
     if (computeEvidenceId(withoutId) !== evidenceId)
         throw new TypeError("Evidence semantic identifier does not match its record");
     return evidence;
 };
-/** Build deterministic Evidence v2 from an immutable artifact subject. */
+/** Build deterministic Evidence from an immutable artifact subject. */
 export const createEvidence = (target, provider, observation) => {
     const subject = target === undefined
         ? null
@@ -175,7 +168,6 @@ export const createEvidence = (target, provider, observation) => {
             local_path: target.path,
         };
     const semantic = {
-        schema_version: 2,
         subject: subject === null
             ? null
             : {
@@ -191,7 +183,7 @@ export const createEvidence = (target, provider, observation) => {
         ...(observation.analysisProfile === undefined
             ? {}
             : { analysis_profile: observation.analysisProfile }),
-        predicate_type: observation.predicateType ?? "rea.analysis/v2",
+        predicate_type: observation.predicateType ?? "rea.analysis",
         operation: observation.operation,
         parameters: observation.parameters,
         raw_result: observation.rawResult ?? null,

package/dist/domain/evidenceBundle.js

@@ -21,7 +21,6 @@ const captureManifestSchema = z.object({
     predicate_type: z.string().min(1),
 });
 export const evidenceBundleSchema = z.object({
-    bundle_version: z.literal(2),
     artifacts: z.array(artifactManifestSchema),
     providers: z.array(providerManifestSchema),
     environments: z.array(environmentManifestSchema),
@@ -34,7 +33,6 @@ export const evidenceBundleSchema = z.object({
 export const createEvidenceBundle = (records, unknowns = []) => {
     const sortedRecords = [...records].sort((left, right) => left.evidence_id.localeCompare(right.evidence_id));
     return {
-        bundle_version: 2,
         artifacts: uniqueSorted(sortedRecords.flatMap(({ subject }) => subject === null
             ? []
             : [
@@ -55,7 +53,7 @@ export const createEvidenceBundle = (records, unknowns = []) => {
                 },
             ]
             : []),
-        captures: sortedRecords.flatMap((evidence) => evidence.predicate_type.startsWith("rea.process-capture/")
+        captures: sortedRecords.flatMap((evidence) => evidence.predicate_type === "rea.process-capture"
             ? [
                 {
                     evidence_id: evidence.evidence_id,
@@ -81,7 +79,7 @@ export const evidenceBundleForTarget = (bundle, sha256) => {
                 return (record?.subject?.digest.sha256 === sha256 ||
                     (unknown.mutation_evidence_ids.includes(id) &&
                         record?.subject === null &&
-                        record.predicate_type === "rea.residual-unknown-mutation/v1"));
+                        record.predicate_type === "rea.residual-unknown-mutation"));
             }));
         changed = retained.length !== unknowns.length;
         unknowns = retained;
@@ -157,7 +155,7 @@ const validateVerifiedResolution = (unknown, evidenceById) => {
         const evidence = evidenceById.get(evidenceId);
         return (unknown.supporting_evidence_ids.includes(evidenceId) &&
             evidence !== undefined &&
-            evidence.predicate_type !== "rea.residual-unknown-mutation/v1" &&
+            evidence.predicate_type !== "rea.residual-unknown-mutation" &&
             evidenceQualifies(unknown, evidence));
     });
     if (qualifies !== true)

package/dist/domain/evidenceCompletionLedger.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,99}$/u);
+const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
 /** Terminal outcome recorded for one verifier claim. */
 export const evidenceCompletionStatusSchema = z.enum([
     "pass",
@@ -15,10 +15,10 @@ export const evidenceCompletionStatusSchema = z.enum([
 export const evidenceCompletionRecordSchema = z.strictObject({
     claim_id: claimIdSchema,
     status: evidenceCompletionStatusSchema,
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const completionSummarySchema = z.strictObject({
-    total: z.number().int().min(1).max(10_000),
+    total: z.number().int().min(1),
     pass: z.number().int().nonnegative(),
     fail: z.number().int().nonnegative(),
     unsupported: z.number().int().nonnegative(),
@@ -27,9 +27,8 @@ const completionSummarySchema = z.strictObject({
     complete: z.boolean(),
 });
 const completionLedgerObjectSchema = z.strictObject({
-    schema_version: z.literal(1),
     ledger_id: z.string().regex(/^ecl_[a-f0-9]{64}$/u),
-    records: z.array(evidenceCompletionRecordSchema).min(1).max(10_000),
+    records: z.array(evidenceCompletionRecordSchema).min(1),
     summary: completionSummarySchema,
 });
 const compareIdentifiers = (left, right) => left < right ? -1 : left > right ? 1 : 0;
@@ -57,7 +56,7 @@ const canonicalJson = (value) => {
     return serialized;
 };
 const computeLedgerId = (records) => `ecl_${createHash("sha256")
-    .update(canonicalJson({ schema_version: 1, records }))
+    .update(canonicalJson({ records }))
     .digest("hex")}`;
 const ledgerIssues = (ledger, context) => {
     if (!isSortedUnique(ledger.records.map((record) => record.claim_id)))
@@ -86,7 +85,7 @@ const ledgerIssues = (ledger, context) => {
             message: "Completion ledger identifier does not match its records",
         });
 };
-/** Strict path-free Evidence v2 completion ledger. */
+/** Strict path-free Evidence completion ledger. */
 export const evidenceCompletionLedgerSchema = completionLedgerObjectSchema.superRefine(ledgerIssues);
 /** Build a canonical path-independent ledger from verifier claim outcomes. */
 export const createEvidenceCompletionLedger = (input) => {
@@ -103,7 +102,6 @@ export const createEvidenceCompletionLedger = (input) => {
         if (!isSortedUnique(record.evidence_ids))
             throw new TypeError("Completion Evidence IDs must be unique per claim");
     return evidenceCompletionLedgerSchema.parse({
-        schema_version: 1,
         ledger_id: computeLedgerId(records),
         records,
         summary: summarize(records),

package/dist/domain/functionComparison.js

@@ -4,19 +4,15 @@ import { functionComparisonResultSchema, } from "./functionComparisonSchemas.js"
 import { overallStatus, summarize, canonicalJson, } from "./functionComparisonResults.js";
 import { compareDimensions } from "./functionComparisonDimensions.js";
 export { functionComparisonInputSchema, functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
-/** Compare two explicit function Evidence page sets without fuzzy matching. */
-export const compareFunctions = (leftInput, rightInput, offset, limit) => {
+/** Compare two complete function Evidence records without fuzzy matching. */
+export const compareFunctions = (leftInput, rightInput) => {
     const left = parseFunctionEvidence(leftInput);
     const right = parseFunctionEvidence(rightInput);
-    const links = [
-        ...left.evidence.map(({ evidence_id: id }) => id),
-        ...right.evidence.map(({ evidence_id: id }) => id),
-    ];
+    const links = [left.evidence[0].evidence_id, right.evidence[0].evidence_id];
     const providersDiffer = canonicalJson(left.provider) !== canonicalJson(right.provider);
     const dimensions = compareDimensions(left, right, links, providersDiffer);
     const match = functionMatch(left, right);
     const changes = dimensions.filter(({ status }) => status !== "unchanged");
-    const page = changes.slice(offset, offset + limit);
     return functionComparisonResultSchema.parse({
         status: overallStatus(dimensions, match.status),
         function_match: match,
@@ -24,13 +20,7 @@ export const compareFunctions = (leftInput, rightInput, offset, limit) => {
         right_subject_sha256: right.subject.digest.sha256,
         summary: summarize(dimensions),
         dimensions,
-        changes: {
-            items: page,
-            offset,
-            limit,
-            total: changes.length,
-            next_offset: offset + page.length < changes.length ? offset + page.length : null,
-        },
+        changes,
         limitations: [
             ...new Set([
                 ...left.limitations.map((item) => `Left: ${item}`),

package/dist/domain/functionComparisonNormalization.js

@@ -123,14 +123,14 @@ export const stringAndNameProjection = (snapshot) => {
         : sorted(values);
 };
 export const sorted = (values) => [...values].sort((left, right) => canonicalJson(left).localeCompare(canonicalJson(right)));
-export const combineCoverage = (left, right) => ({
-    items: [...left.items, ...right.items],
-    total: left.total === null || right.total === null
-        ? null
-        : left.total + right.total,
-    complete: left.complete && right.complete,
-    truncated: left.truncated || right.truncated,
-});
+export const combineCoverage = (left, right) => {
+    return {
+        items: [...left.items, ...right.items],
+        total: left.total + right.total,
+        complete: true,
+        truncated: false,
+    };
+};
 export const project = (collection, mapper) => collection.items.map(mapper);
 export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.)/iu.test(name);
 const parseAddress = (value) => /^0x[0-9a-f]+$/iu.test(value) ? BigInt(value) : null;

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()),
 });