rea-agents 3.0.0 → 3.2.0

package/dist/domain/callPath.js

@@ -1,168 +1,68 @@
 import { DirectedGraph } from "graphology";
 import { bidirectional } from "graphology-shortest-path/unweighted.js";
-import { z } from "zod";
-import { evidenceSchema } from "./evidence.js";
+import { callPathInputSchema, callPathResultSchema, parseCallPathAddress, } from "./callPathSchemas.js";
 import { parseFunctionEvidence, } from "./functionDossierEvidence.js";
-const addressSchema = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]*)$/u);
-const inputAddressSchema = z
-    .string()
-    .regex(/^0[xX][0-9a-fA-F]+$/u)
-    .transform((address) => `0x${BigInt(address).toString(16)}`);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const evidenceGroupSchema = z.union([
-    evidenceSchema,
-    z.array(evidenceSchema).min(1).max(100),
-]);
-const MAX_EVIDENCE_PAGES = 2_000;
-const MAX_GRAPH_EDGES = 10_000;
-const MAX_PATH_EXPANSIONS = 100_000;
-/** Strict, bounded input for explicit call-path reconstruction. */
-export const callPathInputSchema = z
-    .object({
-    functions: z.array(evidenceGroupSchema).min(1).max(500),
-    start: z.object({ address: inputAddressSchema }).strict(),
-    goal: z.object({ address: inputAddressSchema }).strict(),
-    max_depth: z.number().int().min(0).max(32).default(8),
-    max_paths: z.number().int().min(1).max(100).default(10),
-    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(),
-})
-    .superRefine(({ functions }, context) => {
-    const pages = functions.reduce((total, group) => total + (Array.isArray(group) ? group.length : 1), 0);
-    if (pages > MAX_EVIDENCE_PAGES)
-        context.addIssue({
-            code: "custom",
-            message: `Call-path Evidence exceeds ${MAX_EVIDENCE_PAGES} pages`,
-            path: ["functions"],
-        });
-});
-const citedNodeSchema = z.object({
-    address: addressSchema,
-    name: z.string().nullable(),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(100),
-});
-const citedEdgeSchema = z.object({
-    source: addressSchema,
-    target: addressSchema,
-    evidence_links: z.array(evidenceIdSchema).min(1).max(100),
-});
-const pathSchema = z.object({
-    hops: z.number().int().min(0),
-    nodes: z.array(citedNodeSchema).min(1).max(33),
-    edges: z.array(citedEdgeSchema).max(32),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(3_300),
-});
-/** Evidence-cited, bounded directed call-path result. */
-export const callPathResultSchema = z.object({
-    status: z.enum(["found", "not_found", "unknown", "truncated"]),
-    start: addressSchema,
-    goal: addressSchema,
-    shortest_hops: z.number().int().min(0).nullable(),
-    search_scope: z.object({
-        max_depth: z.number().int().min(0).max(32),
-        max_paths: z.number().int().min(1).max(100),
-        exhaustive: z.boolean(),
-    }),
-    explored: z.object({
-        nodes: z.number().int().min(0),
-        edges: z.number().int().min(0),
-        depth_reached: z.number().int().min(0),
-    }),
-    paths: z.object({
-        items: z.array(pathSchema).max(100),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(0).nullable(),
-        returned: z.number().int().min(0).max(100),
-        truncated: z.boolean(),
-        lower_bound: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-    }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(50_000),
-    limitations: z.array(z.string()),
-});
-/** Reconstruct bounded direct-callee paths from explicit analyze_function Evidence. */
+export { callPathInputSchema, callPathResultSchema };
+/** Reconstruct direct-callee paths from explicit analyze_function Evidence. */
 export const buildCallPath = (input) => {
     const parsed = callPathInputSchema.parse(input);
-    const snapshots = parseSnapshots(parsed.functions);
-    assertCompatible(snapshots);
-    if (!snapshots.has(parsed.start.address))
-        throw new TypeError(`No analyze_function Evidence was supplied for start ${parsed.start.address}`);
-    const graph = createGraph(snapshots);
+    const { snapshots, graph } = prepareCallGraph(parsed);
     const search = inspectSearch({
         graph,
         snapshots,
         start: parsed.start.address,
         goal: parsed.goal.address,
-        maxDepth: parsed.max_depth,
     });
     const shortest = graph.hasNode(parsed.start.address) && graph.hasNode(parsed.goal.address)
         ? bidirectional(graph, parsed.start.address, parsed.goal.address)
         : null;
-    const enumeration = shortest === null || shortest.length - 1 > parsed.max_depth
-        ? { paths: [], budgetExhausted: false }
+    const paths = shortest === null
+        ? []
         : enumeratePaths({
             graph,
             start: parsed.start.address,
             goal: parsed.goal.address,
             shortestDepth: shortest.length - 1,
-            maxDepth: parsed.max_depth,
-            limit: parsed.max_paths + 1,
-        });
-    const hasKnownExtraPath = enumeration.paths.length > parsed.max_paths;
-    const capped = hasKnownExtraPath || enumeration.budgetExhausted;
-    const retained = enumeration.paths.slice(0, parsed.max_paths);
-    const paths = retained.map((path) => citePath(path, snapshots));
-    const total = paths.length;
-    const items = paths.slice(parsed.offset, parsed.offset + parsed.limit);
-    const found = paths.length > 0;
-    const exhaustive = search.exhaustive && !capped;
-    const status = callPathStatus({ capped, found, exhaustive });
-    const limitations = [...search.limitations];
-    if (capped)
-        limitations.push(enumeration.budgetExhausted
-            ? `Path enumeration stopped at ${MAX_PATH_EXPANSIONS} expansions`
-            : `Path enumeration stopped at max_paths=${parsed.max_paths}`);
-    if (!found && shortest !== null && shortest.length - 1 > parsed.max_depth)
-        limitations.push(`The shortest observed path exceeds max_depth=${parsed.max_depth}`);
-    return callPathResultSchema.parse({
-        status,
+        }).paths.map((path) => citePath(path, snapshots));
+    const shortestHops = paths[0]?.hops;
+    const found = shortestHops !== undefined;
+    const exhaustive = search.exhaustive;
+    const limitations = search.limitations;
+    const resultContext = {
         start: parsed.start.address,
         goal: parsed.goal.address,
-        shortest_hops: found ? (paths[0]?.hops ?? null) : null,
-        search_scope: {
-            max_depth: parsed.max_depth,
-            max_paths: parsed.max_paths,
-            exhaustive,
-        },
-        explored: {
-            nodes: search.reached.size,
-            edges: [...search.reached.keys()].reduce((count, node) => count + (graph.hasNode(node) ? graph.outDegree(node) : 0), 0),
-            depth_reached: Math.max(0, ...search.reached.values()),
-        },
-        paths: {
-            items,
-            offset: parsed.offset,
-            limit: parsed.limit,
-            total: capped ? null : total,
-            returned: items.length,
-            truncated: capped,
-            lower_bound: total + (hasKnownExtraPath ? 1 : 0),
-            next_offset: parsed.offset + items.length < total
-                ? parsed.offset + items.length
-                : null,
-        },
+        explored: summarizeSearch(graph, search.reached),
         evidence_links: uniqueEvidence(snapshots.values()),
         limitations: [...new Set(limitations)].sort((left, right) => left.localeCompare(right)),
+    };
+    const searchScope = { exhaustive };
+    if (found)
+        return callPathResultSchema.parse({
+            ...resultContext,
+            status: "found",
+            shortest_hops: shortestHops,
+            search_scope: searchScope,
+            paths,
+        });
+    return callPathResultSchema.parse({
+        ...resultContext,
+        status: exhaustive ? "not_found" : "unknown",
+        shortest_hops: null,
+        search_scope: searchScope,
+        paths: [],
     });
 };
-const callPathStatus = ({ capped, found, exhaustive, }) => {
-    if (capped)
-        return "truncated";
-    if (found)
-        return "found";
-    return exhaustive ? "not_found" : "unknown";
+const summarizeSearch = (graph, reached) => ({
+    nodes: reached.size,
+    edges: [...reached.keys()].reduce((count, node) => count + (graph.hasNode(node) ? graph.outDegree(node) : 0), 0),
+    depth_reached: Math.max(0, ...reached.values()),
+});
+const prepareCallGraph = (input) => {
+    const snapshots = parseSnapshots(input.functions);
+    assertCompatible(snapshots);
+    if (!snapshots.has(input.start.address))
+        throw new TypeError(`No analyze_function Evidence was supplied for start ${input.start.address}`);
+    return { snapshots, graph: createGraph(snapshots) };
 };
 const parseSnapshots = (groups) => {
     const snapshots = new Map();
@@ -178,9 +78,10 @@ const parseSnapshots = (groups) => {
     return snapshots;
 };
 const assertCompatible = (snapshots) => {
-    const first = snapshots.values().next().value;
-    if (first === undefined)
+    const firstEntry = snapshots.values().next();
+    if (firstEntry.done)
         return;
+    const first = firstEntry.value;
     for (const snapshot of snapshots.values()) {
         if (snapshot.subject.digest.sha256 !== first.subject.digest.sha256 ||
             snapshot.subject.format !== first.subject.format ||
@@ -200,13 +101,11 @@ const createGraph = (snapshots) => {
             const calleeAddress = normalizeAddress(callee.address);
             graph.mergeNode(calleeAddress);
             graph.mergeDirectedEdge(address, calleeAddress);
-            if (graph.size > MAX_GRAPH_EDGES)
-                throw new TypeError(`Call graph exceeds ${MAX_GRAPH_EDGES} directed edges`);
         }
     }
     return graph;
 };
-const inspectSearch = ({ graph, snapshots, start, goal, maxDepth, }) => {
+const inspectSearch = ({ graph, snapshots, start, goal, }) => {
     if (!graph.hasNode(start))
         return {
             graph,
@@ -232,16 +131,9 @@ const inspectSearch = ({ graph, snapshots, start, goal, maxDepth, }) => {
             limitations.push(`No analyze_function Evidence covers reachable function ${node}`);
             continue;
         }
-        if (!snapshot.collections.callees.complete)
-            limitations.push(`Callee coverage is incomplete for reachable function ${node}`);
         const neighbors = graph
             .outNeighbors(node)
             .sort((left, right) => left.localeCompare(right));
-        if (depth === maxDepth) {
-            if (neighbors.length > 0)
-                limitations.push(`Search reached max_depth=${maxDepth} at ${node}`);
-            continue;
-        }
         for (const neighbor of neighbors)
             if (!reached.has(neighbor)) {
                 reached.set(neighbor, depth + 1);
@@ -256,7 +148,7 @@ const inspectSearch = ({ graph, snapshots, start, goal, maxDepth, }) => {
         limitations,
     };
 };
-const enumeratePaths = ({ graph, start, goal, shortestDepth, maxDepth, limit, }) => {
+const enumeratePaths = ({ graph, start, goal, shortestDepth, }) => {
     const output = [];
     const state = {
         graph,
@@ -264,23 +156,14 @@ const enumeratePaths = ({ graph, start, goal, shortestDepth, maxDepth, limit, })
         path: [start],
         visited: new Set([start]),
         output,
-        limit,
-        expansions: 0,
-        budgetExhausted: false,
     };
-    for (let depth = shortestDepth; depth <= maxDepth && output.length < limit; depth += 1)
-        enumerateAtDepth(state, depth);
-    return { paths: output, budgetExhausted: state.budgetExhausted };
+    enumerateAtDepth(state, shortestDepth);
+    return { paths: output };
 };
 const enumerateAtDepth = (state, remaining) => {
-    const { graph, goal, path, visited, output, limit } = state;
-    state.expansions += 1;
-    if (state.expansions > MAX_PATH_EXPANSIONS) {
-        state.budgetExhausted = true;
-        return;
-    }
+    const { graph, goal, path, visited, output } = state;
     const current = path.at(-1);
-    if (current === undefined || output.length >= limit)
+    if (current === undefined)
         return;
     if (remaining === 0) {
         if (current === goal)
@@ -299,8 +182,6 @@ const enumerateAtDepth = (state, remaining) => {
         enumerateAtDepth(state, remaining - 1);
         path.pop();
         visited.delete(neighbor);
-        if (output.length >= limit || state.budgetExhausted)
-            return;
     }
 };
 const citePath = (addresses, snapshots) => {
@@ -343,4 +224,4 @@ const snapshotLinks = (snapshot) => {
 const uniqueEvidence = (snapshots) => [
     ...new Set([...snapshots].flatMap((snapshot) => snapshotLinks(snapshot))),
 ].sort((left, right) => left.localeCompare(right));
-const normalizeAddress = (input) => inputAddressSchema.parse(input);
+const normalizeAddress = (input) => parseCallPathAddress(input);

package/dist/domain/callPathSchemas.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { evidenceSchema } from "./evidence.js";
+const addressSchema = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]*)$/u);
+const inputAddressSchema = z
+    .string()
+    .regex(/^0[xX][0-9a-fA-F]+$/u)
+    .transform((address) => `0x${BigInt(address).toString(16)}`);
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+/** Parse a caller-supplied hexadecimal address into canonical form. */
+export const parseCallPathAddress = (input) => inputAddressSchema.parse(input);
+/** Strict input for explicit call-path reconstruction from complete dossiers. */
+export const callPathInputSchema = z.object({
+    functions: z.array(evidenceSchema).min(1),
+    start: z.object({ address: inputAddressSchema }).strict(),
+    goal: z.object({ address: inputAddressSchema }).strict(),
+});
+const citedNodeSchema = z.object({
+    address: addressSchema,
+    name: z.string().nullable(),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+});
+const citedEdgeSchema = z.object({
+    source: addressSchema,
+    target: addressSchema,
+    evidence_links: z.array(evidenceIdSchema).min(1),
+});
+const pathSchema = z
+    .object({
+    hops: z.number().int().min(0),
+    nodes: z.array(citedNodeSchema).min(1),
+    edges: z.array(citedEdgeSchema),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+})
+    .superRefine((path, context) => {
+    const edgesConnectNodes = path.edges.every((edge, index) => edge.source === path.nodes[index]?.address &&
+        edge.target === path.nodes[index + 1]?.address);
+    if (path.hops !== path.edges.length ||
+        path.nodes.length !== path.edges.length + 1 ||
+        !edgesConnectNodes)
+        context.addIssue({
+            code: "custom",
+            message: "Path hops and edges must connect the ordered nodes",
+        });
+});
+const resultContextShape = {
+    start: addressSchema,
+    goal: addressSchema,
+    explored: z.object({
+        nodes: z.number().int().min(0),
+        edges: z.number().int().min(0),
+        depth_reached: z.number().int().min(0),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(z.string()),
+};
+/** Evidence-cited directed call-path result containing every shortest path. */
+export const callPathResultSchema = z.union([
+    z.object({
+        ...resultContextShape,
+        status: z.literal("found"),
+        shortest_hops: z.number().int().min(0),
+        search_scope: z.object({ exhaustive: z.boolean() }),
+        paths: z.array(pathSchema).min(1),
+    }),
+    z.object({
+        ...resultContextShape,
+        status: z.literal("not_found"),
+        shortest_hops: z.null(),
+        search_scope: z.object({ exhaustive: z.literal(true) }),
+        paths: z.tuple([]),
+    }),
+    z.object({
+        ...resultContextShape,
+        status: z.literal("unknown"),
+        shortest_hops: z.null(),
+        search_scope: z.object({ exhaustive: z.literal(false) }),
+        paths: z.tuple([]),
+    }),
+]);

package/dist/domain/changedBehavior.js

@@ -3,24 +3,10 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { functionComparisonResultSchema } from "./functionComparison.js";
 import { comparisonStatusSchema, deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, } from "./processCapture.js";
-import { crossVersionInvestigationInputSchema, investigationRunSummarySchema, } from "./investigationWorkspace.js";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-/** Strict bounded input for aggregating existing comparison Evidence. */
-export const changedBehaviorInputSchema = z
-    .object({
-    comparisons: z.array(evidenceSchema).max(100).default([]),
-    investigation_run: crossVersionInvestigationInputSchema.optional(),
-    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(),
-})
-    .superRefine((input, context) => {
-    if (input.comparisons.length > 0 ===
-        (input.investigation_run !== undefined))
-        context.addIssue({
-            code: "custom",
-            message: "Supply either existing comparisons or one investigation_run, but not both",
-        });
+/** Input for aggregating existing comparison Evidence. */
+export const changedBehaviorInputSchema = z.object({
+    comparisons: z.array(evidenceSchema).default([]),
 });
 const findingSchema = z.object({
     scope: z.enum(["runtime", "protocol", "resource", "static_candidate"]),
@@ -33,11 +19,12 @@ const findingSchema = z.object({
     ]),
     status: comparisonStatusSchema,
     source_comparison_id: evidenceIdSchema,
-    evidence_links: z.array(evidenceIdSchema).min(3).max(201),
+    evidence_links: z.array(evidenceIdSchema).min(3),
     limitations: z.array(z.string()),
 });
 /** Truthful aggregate: runtime observations remain separate from static candidates. */
-export const changedBehaviorResultSchema = z.object({
+export const changedBehaviorResultSchema = z
+    .object({
     behavior_status: z.enum([
         "observed_changed",
         "observed_unchanged",
@@ -51,31 +38,44 @@ export const changedBehaviorResultSchema = z.object({
         unresolved: z.number().int().min(0),
     }),
     findings: z.object({
-        items: z.array(findingSchema).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(),
+        items: z.array(findingSchema),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(3).max(20_100),
+    evidence_links: z.array(evidenceIdSchema).min(3),
     limitations: z.array(z.string()),
-    investigation_run: investigationRunSummarySchema.optional(),
+})
+    .superRefine((result, context) => {
+    const summaryTotal = Object.values(result.summary).reduce((total, count) => total + count, 0);
+    if (summaryTotal !== result.findings.items.length)
+        context.addIssue({
+            code: "custom",
+            message: "Finding classification counts must equal the finding total",
+            path: ["summary"],
+        });
+    if ((result.behavior_status === "observed_changed" &&
+        result.summary.observed_changes === 0) ||
+        (result.behavior_status === "observed_unchanged" &&
+            result.summary.observed_changes > 0))
+        context.addIssue({
+            code: "custom",
+            message: "Observed-change status must agree with runtime findings",
+            path: ["behavior_status"],
+        });
 });
 const EXPECTED_PROVIDERS = {
     compare_process_captures: {
-        predicates: ["rea.process-comparison/v3", "rea.process-comparison/v4"],
+        predicates: ["rea.process-comparison"],
         id: "rea-process",
         name: "REA deterministic process harness",
         version: "3",
     },
     compare_artifacts: {
-        predicates: ["rea.artifact-comparison/v1"],
+        predicates: ["rea.artifact-comparison"],
         id: "rea-artifact-comparison",
         name: "REA artifact comparison",
         version: "1",
     },
     compare_functions: {
-        predicates: ["rea.function-comparison/v1"],
+        predicates: ["rea.function-comparison"],
         id: "rea-function-comparison",
         name: "REA function comparison",
         version: "1",
@@ -83,11 +83,9 @@ const EXPECTED_PROVIDERS = {
 };
 const acceptsPredicate = (expected, actual) => expected.some((predicate) => predicate === actual);
 /** Find observed runtime changes and separately report static change candidates. */
-export const findChangedBehavior = (comparisonsInput, offset, limit) => {
+export const findChangedBehavior = (comparisonsInput) => {
     const parsedInput = changedBehaviorInputSchema.parse({
         comparisons: comparisonsInput,
-        offset,
-        limit,
     });
     const comparisons = parsedInput.comparisons;
     const evidence = comparisons.map(parseComparisonEvidence);
@@ -95,9 +93,6 @@ export const findChangedBehavior = (comparisonsInput, offset, limit) => {
     const findings = evidence.flatMap(findingsFor).sort(compareFindings);
     const runtimeStatuses = evidence.flatMap(runtimeStatus);
     const links = uniqueSorted(evidence.flatMap((item) => [item.evidence_id, ...item.evidence_links]));
-    if (links.length > 20_100)
-        throw new TypeError("Changed-behavior Evidence closure exceeds limit");
-    const page = findings.slice(parsedInput.offset, parsedInput.offset + parsedInput.limit);
     return changedBehaviorResultSchema.parse({
         behavior_status: behaviorStatus(runtimeStatuses),
         summary: {
@@ -107,13 +102,7 @@ export const findChangedBehavior = (comparisonsInput, offset, limit) => {
             unresolved: count(findings, "unresolved_branch"),
         },
         findings: {
-            items: page,
-            offset: parsedInput.offset,
-            limit: parsedInput.limit,
-            total: findings.length,
-            next_offset: parsedInput.offset + page.length < findings.length
-                ? parsedInput.offset + page.length
-                : null,
+            items: findings,
         },
         evidence_links: links,
         limitations: uniqueSorted([
@@ -126,7 +115,6 @@ export const findChangedBehavior = (comparisonsInput, offset, limit) => {
             ...(runtimeStatuses.length === 0
                 ? ["No process comparison Evidence was supplied."]
                 : []),
-            ...evidence.flatMap(artifactPaginationLimitations),
         ]),
     });
 };
@@ -170,9 +158,7 @@ const parseResult = (evidence) => {
         return;
     }
     const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-    if (result.changes.offset !== 0)
-        throw new TypeError("Changed-behavior analysis requires artifact comparison pagination from offset zero");
-    assertNestedLinks(evidence, result.changes.items.flatMap(({ evidence_links: links }) => links));
+    assertNestedLinks(evidence, result.changes.flatMap(({ evidence_links: links }) => links));
 };
 const assertNestedLinks = (evidence, nestedLinks) => {
     const topLevel = new Set(evidence.evidence_links);
@@ -232,7 +218,7 @@ const functionFindings = (evidence) => {
 };
 const artifactFindings = (evidence) => {
     const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-    const changes = result.changes.items.map((change) => makeFinding({
+    const changes = result.changes.map((change) => makeFinding({
         evidence,
         dimension: `artifact:${change.logical_path}`,
         scope: "static_candidate",
@@ -245,9 +231,7 @@ const artifactFindings = (evidence) => {
         limitations: result.limitations,
         links: change.evidence_links,
     }));
-    return (result.status === "unknown" ||
-        result.status === "truncated" ||
-        result.changes.next_offset !== null) &&
+    return (result.status === "unknown" || result.status === "truncated") &&
         !changes.some(({ classification }) => classification === "unresolved_branch")
         ? [
             ...changes,
@@ -262,16 +246,6 @@ const artifactFindings = (evidence) => {
         ]
         : changes;
 };
-const artifactPaginationLimitations = (evidence) => {
-    if (evidence.operation !== "compare_artifacts")
-        return [];
-    const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-    return result.changes.next_offset === null
-        ? []
-        : [
-            `Artifact comparison reports ${String(result.changes.items.length)} of ${String(result.changes.total)} changes.`,
-        ];
-};
 const makeFinding = (input) => findingSchema.parse({
     scope: input.scope,
     dimension: input.dimension,

package/dist/domain/completionLedgerGeneration.js

@@ -2,17 +2,17 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import { createEvidenceCompletionLedger, evidenceCompletionRecordSchema, } from "./evidenceCompletionLedger.js";
-const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,99}$/u);
+const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const identitySchema = z.strictObject({
     id: identifierSchema,
-    version: z.string().min(1).max(100),
+    version: z.string().min(1),
 });
 const environmentSchema = z.strictObject({
     platform: identifierSchema,
     architecture: identifierSchema,
     runtime: identifierSchema,
-    runtime_version: z.string().min(1).max(100),
+    runtime_version: z.string().min(1),
 });
 const scenarioSchema = z.strictObject({
     id: identifierSchema,
@@ -24,14 +24,12 @@ const skillDigestSchema = z.strictObject({
 });
 const verifierRunSchema = z
     .strictObject({
-    schema_version: z.literal(1),
     run_id: z.string().uuid(),
     verifier_pid: z.number().int().positive(),
     parent_pid: z.number().int().nonnegative(),
     process_lineage: z.discriminatedUnion("status", [
         z.strictObject({
             status: z.literal("verified"),
-            schema_version: z.literal(1),
             observed_at: z.iso.datetime(),
             launcher_pid: z.number().int().positive(),
             launcher_parent_pid: z.number().int().nonnegative(),
@@ -48,7 +46,7 @@ const verifierRunSchema = z
             launcher_pid: z.number().int().positive(),
             launcher_parent_pid: z.number().int().nonnegative(),
             process_group_id: z.number().int().positive().nullable(),
-            reason: z.string().min(1).max(500),
+            reason: z.string().min(1),
         }),
     ]),
 })
@@ -69,18 +67,16 @@ const verifierRunSchema = z
 const reportClaimSchema = z.strictObject({
     claim_id: identifierSchema,
     scenario: scenarioSchema,
-    artifact_sha256s: z.array(digestSchema).max(100),
+    artifact_sha256s: z.array(digestSchema),
     provider: identitySchema,
-    result_schema_version: z.number().int().positive(),
     status: evidenceCompletionRecordSchema.shape.status,
     evidence_ids: evidenceCompletionRecordSchema.shape.evidence_ids,
 });
 const completionVerifierReportObjectSchema = z.strictObject({
-    schema_version: z.literal(1),
     verifier: identitySchema,
     verifier_run: verifierRunSchema,
     environment: environmentSchema,
-    claims: z.array(reportClaimSchema).min(1).max(10_000),
+    claims: z.array(reportClaimSchema).min(1),
 });
 /** Strict output contract implemented by completion-aware verifiers. */
 export const completionVerifierReportSchema = completionVerifierReportObjectSchema.superRefine((report, context) => {
@@ -97,12 +93,11 @@ const manifestClaimSchema = reportClaimSchema.omit({
     evidence_ids: true,
 });
 const completionManifestObjectSchema = z.strictObject({
-    schema_version: z.literal(1),
     manifest_id: z.string().regex(/^ecm_[a-f0-9]{64}$/u),
     verifier: identitySchema,
     environment: environmentSchema,
-    skill_digests: z.array(skillDigestSchema).min(1).max(100),
-    claims: z.array(manifestClaimSchema).min(1).max(10_000),
+    skill_digests: z.array(skillDigestSchema).min(1),
+    claims: z.array(manifestClaimSchema).min(1),
 });
 const compareIdentifiers = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const isSortedUnique = (values) => values.every((value, index) => index === 0 || compareIdentifiers(values[index - 1] ?? "", value) < 0);
@@ -168,7 +163,6 @@ export const createCompletionLedgerArtifacts = (input, skillDigests) => {
     if (!isSortedUnique(skills.map(({ skill_id }) => skill_id)))
         throw new TypeError("Completion skill IDs must be unique");
     const projection = {
-        schema_version: 1,
         verifier: report.verifier,
         environment: report.environment,
         skill_digests: skills,