rea-agents 3.0.0 → 3.2.0

package/dist/application/ProjectPermissionStore.js

@@ -1,31 +1,16 @@
+import { createStoreFileLock, removeStaleStoreFileLock, } from "./StoreFileLock.js";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
-import { lstat, mkdir, open, readFile, realpath, unlink, } from "node:fs/promises";
+import { lstat, mkdir, open, realpath, } from "node:fs/promises";
 import { dirname } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
+import { PERMISSION_CAPABILITIES, } from "../domain/permissionPolicy.js";
 import { err, ok } from "../domain/result.js";
 const grantSchema = z.object({
     grant_id: z.string().min(1),
-    capability: z.enum([
-        "process_capture",
-        "browser_observe",
-        "browser_automate",
-        "electron_observe",
-        "evidence_read",
-        "evidence_write",
-        "investigation_input",
-        "investigation_workspace_read",
-        "investigation_workspace_write",
-        "snapshot_read",
-        "snapshot_write",
-        "artifact_extract",
-        "native_mount",
-        "reference_read",
-        "javascript_replay",
-        "managed_runtime",
-    ]),
+    capability: z.enum(PERMISSION_CAPABILITIES),
     roots: z.array(z.string()),
     executables: z.array(z.string()),
     environment_names: z.array(z.string()),
@@ -37,10 +22,9 @@ const grantSchema = z.object({
     expires_at: z.iso.datetime().nullable(),
 });
 const storeSchema = z.object({
-    schema_version: z.literal(1),
     project_id: z.string().regex(/^project_[a-f0-9]{64}$/u),
     project_root: z.string(),
-    grants: z.array(grantSchema).max(1_000),
+    grants: z.array(grantSchema),
 });
 /** Owner-only project policy persistence failure. */
 export class ProjectPermissionStoreError extends Error {
@@ -109,7 +93,6 @@ export const writeProjectPermissionStore = async (path, projectRoot, grants) =>
     if (!project.ok)
         return project;
     const candidate = storeSchema.safeParse({
-        schema_version: 1,
         project_id: project.value.id,
         project_root: project.value.root,
         grants,
@@ -118,26 +101,38 @@ export const writeProjectPermissionStore = async (path, projectRoot, grants) =>
         return err(new ProjectPermissionStoreError("invalid", { cause: candidate.error }));
     if (process.getuid === undefined)
         return err(new ProjectPermissionStoreError("not_owner_only"));
-    try {
-        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-        await writeFileAtomic(path, `${JSON.stringify(candidate.data, null, 2)}\n`, {
-            encoding: "utf8",
-            mode: 0o600,
-        });
-        const verified = await readProjectPermissionStore(path, projectRoot);
-        if (!verified.ok)
-            return verified;
-        if (verified.value === null ||
-            JSON.stringify(verified.value) !== JSON.stringify(candidate.data))
-            return err(new ProjectPermissionStoreError("invalid"));
-        return ok(candidate.data);
-    }
-    catch (cause) {
-        return err(new ProjectPermissionStoreError("io", { cause }));
-    }
+    return withPermissionStoreLock(path, () => writePreparedPermissionStore(path, projectRoot, candidate.data));
+};
+const writePreparedPermissionStore = async (path, projectRoot, candidate) => {
+    await writeFileAtomic(path, `${JSON.stringify(candidate, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    const verified = await readProjectPermissionStore(path, projectRoot);
+    if (!verified.ok)
+        return verified;
+    if (verified.value === null ||
+        JSON.stringify(verified.value) !== JSON.stringify(candidate))
+        return err(new ProjectPermissionStoreError("invalid"));
+    return ok(candidate);
 };
 /** Revoke one grant while serializing the complete read-modify-write cycle. */
-export const revokeProjectPermissionGrant = async (path, projectRoot, grantId) => {
+export const revokeProjectPermissionGrant = async (path, projectRoot, grantId) => withPermissionStoreLock(path, async () => {
+    const current = await readProjectPermissionStore(path, projectRoot);
+    if (!current.ok)
+        return current;
+    if (current.value === null)
+        return ok(false);
+    const retained = current.value.grants.filter(({ grant_id }) => grant_id !== grantId);
+    if (retained.length === current.value.grants.length)
+        return ok(false);
+    const written = await writePreparedPermissionStore(path, projectRoot, {
+        ...current.value,
+        grants: retained,
+    });
+    return written.ok ? ok(true) : written;
+});
+const withPermissionStoreLock = async (path, action) => {
     let lock;
     try {
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
@@ -145,34 +140,26 @@ export const revokeProjectPermissionGrant = async (path, projectRoot, grantId) =
         if (!acquired.ok)
             return acquired;
         lock = acquired.value;
-        const current = await readProjectPermissionStore(path, projectRoot);
-        if (!current.ok)
-            return current;
-        const grants = current.value?.grants ?? [];
-        const retained = grants.filter(({ grant_id }) => grant_id !== grantId);
-        if (retained.length === grants.length)
-            return ok(false);
-        const written = await writeProjectPermissionStore(path, projectRoot, retained);
-        return written.ok ? ok(true) : written;
+        return await action();
     }
     catch (cause) {
         return err(new ProjectPermissionStoreError("io", { cause }));
     }
     finally {
         if (lock !== undefined)
-            await releasePermissionStoreLock(lock);
+            await lock.release();
     }
 };
 const acquirePermissionStoreLock = async (destination) => {
     const path = `${destination}.lock`;
     for (let attempt = 0; attempt < 100; attempt += 1) {
         try {
-            return ok(await createPermissionStoreLock(path));
+            return ok(await createStoreFileLock(path));
         }
         catch (cause) {
             if (!isAlreadyExists(cause))
                 return err(new ProjectPermissionStoreError("io", { cause }));
-            if (await removeStalePermissionStoreLock(path))
+            if (await removeStaleStoreFileLock(path))
                 continue;
             if (attempt === 99)
                 return err(new ProjectPermissionStoreError("locked", { cause }));
@@ -181,49 +168,6 @@ const acquirePermissionStoreLock = async (destination) => {
     }
     return err(new ProjectPermissionStoreError("locked"));
 };
-const createPermissionStoreLock = async (path) => {
-    const handle = await open(path, "wx", 0o600);
-    try {
-        await handle.writeFile(`${String(process.pid)}\n`, "utf8");
-        await handle.sync();
-        return { path, handle };
-    }
-    catch (cause) {
-        await handle.close().catch(() => undefined);
-        await unlink(path).catch(() => undefined);
-        throw cause;
-    }
-};
-const removeStalePermissionStoreLock = async (path) => {
-    try {
-        const metadata = await lstat(path);
-        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 32)
-            return false;
-        const encoded = (await readFile(path, "utf8")).trim();
-        if (!/^[1-9][0-9]{0,9}$/u.test(encoded))
-            return false;
-        if (processIsAlive(Number(encoded)))
-            return false;
-        await unlink(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const processIsAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== "ESRCH";
-    }
-};
-const releasePermissionStoreLock = async (lock) => {
-    await lock.handle.close().catch(() => undefined);
-    await unlink(lock.path).catch(() => undefined);
-};
 const isNotFound = (cause) => errorCode(cause) === "ENOENT";
 const openPrivateStore = async (path) => {
     let handle;

package/dist/application/RealHopperAssertions.js

@@ -1,28 +1,14 @@
 import { z } from "zod";
 const addressSchema = z.string().regex(/^0x[0-9a-f]+$/iu);
 const identitySchema = z.object({ address: addressSchema, name: z.string() });
-const collectionSchema = z.object({
-    items: z.array(z.unknown()),
-    total: z.number().int().min(0).nullable(),
-    returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-});
-/** Extract a real address from the provider's exact procedure page. */
+/** Extract one real procedure address from the complete inline inventory. */
 export const firstProcedureAddress = (input) => {
-    const page = z
-        .object({
-        items: z.array(z.object({ address: addressSchema })).min(1),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(1),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    })
-        .parse(input);
-    const first = page.items[0];
+    const first = z
+        .array(z.object({ address: addressSchema }))
+        .min(1)
+        .parse(input)[0];
     if (first === undefined)
-        throw new TypeError("Procedure page was empty");
+        throw new TypeError("Procedure inventory was empty");
     return first.address;
 };
 /** Reject two target paths that resolve to the same binary content. */
@@ -44,7 +30,7 @@ export const requirePseudocode = (input, operation) => {
         throw new TypeError(`${operation} returned an embedded failure: ${input}`);
     return input;
 };
-/** Validate an exact bounded Hopper function dossier semantically. */
+/** Validate a complete Hopper function dossier semantically. */
 export const requireFunctionDossier = (input, expectedAddress) => {
     const value = objectValue(input, "analyze_function returned no function dossier");
     const procedure = identitySchema.parse(value.procedure);
@@ -52,22 +38,19 @@ export const requireFunctionDossier = (input, expectedAddress) => {
         throw new TypeError("analyze_function returned the wrong procedure");
     if (procedure.name.trim().length === 0)
         throw new TypeError("analyze_function omitted the procedure name");
-    validatePseudocodeBounds(value.pseudocode);
+    requirePseudocode(value.pseudocode, "analyze_function");
     for (const field of COLLECTION_FIELDS)
-        validateCollection(value[field], field);
+        list(value, field);
     for (const field of ["callers", "callees"])
-        z.array(identitySchema).parse(collectionSchema.parse(value[field]).items);
-    validateBlocks(collectionSchema.parse(value.basic_blocks).items);
-    validateInstructionScan(value.instruction_scan);
+        z.array(identitySchema).parse(list(value, field));
+    validateBlocks(list(value, "basic_blocks"));
     return value;
 };
 /** Reject a structurally valid dossier that omits fixture-proven semantics. */
 export const requireFunctionDossierOracle = (input, oracle) => {
     const value = requireFunctionDossier(input, oracle.procedure_address);
     if (oracle.callee_address !== undefined) {
-        const callees = z
-            .array(identitySchema)
-            .parse(collectionSchema.parse(value.callees).items);
+        const callees = z.array(identitySchema).parse(list(value, "callees"));
         if (!callees.some(({ address }) => address === oracle.callee_address))
             throw new TypeError("analyze_function omitted the expected fixture callee");
         const references = z
@@ -75,14 +58,12 @@ export const requireFunctionDossierOracle = (input, oracle) => {
             source_address: addressSchema,
             target_address: addressSchema,
         }))
-            .parse(collectionSchema.parse(value.outgoing_references).items);
+            .parse(list(value, "outgoing_references"));
         if (!references.some(({ target_address }) => target_address === oracle.callee_address))
             throw new TypeError("analyze_function omitted the expected fixture reference");
     }
     if (oracle.caller_address !== undefined) {
-        const callers = z
-            .array(identitySchema)
-            .parse(collectionSchema.parse(value.callers).items);
+        const callers = z.array(identitySchema).parse(list(value, "callers"));
         if (!callers.some(({ address }) => address === oracle.caller_address))
             throw new TypeError("analyze_function omitted the expected fixture caller");
     }
@@ -97,19 +78,18 @@ export const requireFunctionDossierOracle = (input, oracle) => {
             kind: z.enum(["comment", "inline"]),
             text: z.string(),
         }))
-            .parse(collectionSchema.parse(value.comments).items);
+            .parse(list(value, "comments"));
         if (!comments.some(({ address, kind, text }) => address === oracle.procedure_address &&
             kind === "comment" &&
             text === oracle.comment))
             throw new TypeError("analyze_function omitted the verifier comment");
     }
-    if (oracle.require_assembly === true &&
-        collectionSchema.parse(value.assembly).items.length === 0)
+    if (oracle.require_assembly === true && list(value, "assembly").length === 0)
         throw new TypeError("analyze_function omitted fixture assembly");
     if (oracle.require_cfg_successor) {
         const blocks = z
             .array(z.object({ successors: z.array(addressSchema) }))
-            .parse(collectionSchema.parse(value.basic_blocks).items);
+            .parse(list(value, "basic_blocks"));
         if (!blocks.some(({ successors }) => successors.length > 0))
             throw new TypeError("analyze_function omitted a real CFG successor");
     }
@@ -125,12 +105,10 @@ const referenceEdgeSchema = z.object({
     target_address: addressSchema,
 });
 const requireReferencedValue = (dossier, field, expected, normalize) => {
-    const values = z
-        .array(referencedValueSchema)
-        .parse(collectionSchema.parse(dossier[field]).items);
+    const values = z.array(referencedValueSchema).parse(list(dossier, field));
     const references = z
         .array(referenceEdgeSchema)
-        .parse(collectionSchema.parse(dossier.outgoing_references).items);
+        .parse(list(dossier, "outgoing_references"));
     const found = values.some(({ address, value, source_address: sourceAddress }) => normalize(value) === expected &&
         references.some(({ source_address, target_address }) => source_address === sourceAddress && target_address === address));
     if (!found)
@@ -154,36 +132,12 @@ const COLLECTION_FIELDS = [
     "referenced_names",
     "basic_blocks",
 ];
-const validatePseudocodeBounds = (input) => {
-    const pseudocode = z
-        .object({
-        text: z.string(),
-        returned_chars: z.number().int().min(0),
-        total_chars: z.number().int().min(0),
-    })
-        .parse(input);
-    const text = requirePseudocode(pseudocode.text, "analyze_function");
-    if (pseudocode.returned_chars !== [...text].length ||
-        pseudocode.total_chars < pseudocode.returned_chars)
-        throw new TypeError("analyze_function returned inconsistent pseudocode bounds");
-};
-const validateCollection = (input, field) => {
-    const collection = collectionSchema.parse(input);
-    if (collection.returned !== collection.items.length)
-        throw new TypeError(`analyze_function returned an invalid ${field} result`);
-};
+const list = (value, field) => z.array(z.unknown()).parse(value[field]);
 const validateBlocks = (items) => {
     for (const block of items)
         if (!Array.isArray(objectValue(block, "Invalid basic block").successors))
             throw new TypeError("analyze_function omitted CFG successor evidence");
 };
-const validateInstructionScan = (input) => {
-    const scan = z
-        .object({ scanned: z.number().int().min(0), truncated: z.boolean() })
-        .parse(input);
-    if (scan.scanned === 0 && !scan.truncated)
-        throw new TypeError("analyze_function omitted instruction scan limitations");
-};
 const objectValue = (input, message) => {
     const parsed = z.record(z.string(), z.unknown()).safeParse(input);
     if (!parsed.success)

package/dist/application/ReconstructionCoverageService.js

@@ -1,69 +1,23 @@
 import { z } from "zod";
-import { AnalysisCancelledError, AnalysisInputError, } from "../domain/errors.js";
+import { AnalysisInputError } from "../domain/errors.js";
+import { evaluateReconstructionClosure, reconstructionCoverageDataSchema, } from "../domain/reconstructionCoverage.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { evaluateReconstructionClosure, reconstructionCoverageWorkspaceSchema, } from "../domain/reconstructionCoverage.js";
 import { err, ok } from "../domain/result.js";
-import { readReconstructionCoverageWorkspace, writeReconstructionCoverageWorkspace, } from "./ReconstructionCoverageWorkspaceStore.js";
-const COMMIT_OPERATION = "commit_reconstruction_coverage";
-const QUERY_OPERATION = "query_reconstruction_coverage";
-const isAborted = (signal) => signal?.aborted === true;
-export const reconstructionCoverageCommitInputSchema = z.strictObject({
-    approved: z.literal(true),
-    workspace_path: z.string().min(1).max(4_096),
-    expected_revision: z.number().int().min(1).nullable(),
-    workspace: reconstructionCoverageWorkspaceSchema,
+export const reconstructionCoverageEvaluationInputSchema = z.strictObject({
+    coverage: reconstructionCoverageDataSchema,
+    boundary_id: z.string().min(1),
 });
-export const reconstructionCoverageQueryInputSchema = z.strictObject({
-    workspace_path: z.string().min(1).max(4_096),
-    boundary_id: z.string().min(1).max(200),
-});
-export const reconstructionCoverageCommitOutputSchema = z.strictObject({
-    workspace_path: z.string(),
-    bytes: z.number().int().min(0),
-    workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-    revision: z.number().int().min(1),
-    revision_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    evidence_records: z.number().int().min(0),
-});
-/** Commit one caller-approved canonical reconstruction coverage CAS revision. */
-export const commitReconstructionCoverage = async (rawInput, policy, options = {}) => {
-    const parsed = reconstructionCoverageCommitInputSchema.safeParse(rawInput);
-    if (!parsed.success)
-        return err(new AnalysisInputError(COMMIT_OPERATION, { cause: parsed.error }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(COMMIT_OPERATION));
-    const written = await writeReconstructionCoverageWorkspace(parsed.data.workspace, parsed.data.workspace_path, parsed.data.expected_revision, policy);
-    if (!written.ok)
-        return written;
-    return ok(jsonValueSchema.parse({
-        workspace_path: written.value.path,
-        bytes: written.value.bytes,
-        workspace_id: parsed.data.workspace.workspace_id,
-        revision: parsed.data.workspace.revision,
-        revision_sha256: parsed.data.workspace.revision_sha256,
-        evidence_records: parsed.data.workspace.evidence_bundle.records.length,
-    }));
-};
-/** Read one coverage revision and evaluate a named fail-closed boundary. */
-export const queryReconstructionCoverage = async (rawInput, policy, nowEpochMs, options = {}) => {
-    const parsed = reconstructionCoverageQueryInputSchema.safeParse(rawInput);
+/** Evaluate inline reconstruction coverage against a named boundary. */
+export const evaluateReconstructionCoverage = (rawInput, nowEpochMs = Date.now()) => {
+    const parsed = reconstructionCoverageEvaluationInputSchema.safeParse(rawInput);
     if (!parsed.success)
-        return err(new AnalysisInputError(QUERY_OPERATION, { cause: parsed.error }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(QUERY_OPERATION));
-    const loaded = await readReconstructionCoverageWorkspace(parsed.data.workspace_path, policy);
-    if (!loaded.ok)
-        return loaded;
-    if (loaded.value === null)
-        return err(new AnalysisInputError(QUERY_OPERATION, {
-            cause: new TypeError("Reconstruction coverage workspace does not exist"),
+        return err(new AnalysisInputError("evaluate_reconstruction_coverage", {
+            cause: parsed.error,
         }));
-    if (isAborted(options.signal))
-        return err(new AnalysisCancelledError(QUERY_OPERATION));
     try {
-        return ok(jsonValueSchema.parse(evaluateReconstructionClosure(loaded.value, parsed.data.boundary_id, nowEpochMs)));
+        return ok(jsonValueSchema.parse(evaluateReconstructionClosure(parsed.data.coverage, parsed.data.boundary_id, nowEpochMs)));
     }
     catch (cause) {
-        return err(new AnalysisInputError(QUERY_OPERATION, { cause }));
+        return err(new AnalysisInputError("evaluate_reconstruction_coverage", { cause }));
     }
 };

package/dist/application/ReconstructionObligationAuthority.js

@@ -42,7 +42,7 @@ export const proofAuthoritySatisfies = (actual, required) => {
 export const evidenceAuthoritySupportsProof = (evidence, authority, expected) => {
     if (evidence.confidence !== "observed" ||
         !proofEvidenceAuthorities[authority].includes(evidence.authority) ||
-        evidence.predicate_type !== "rea.reconstruction-proof/v1" ||
+        evidence.predicate_type !== "rea.reconstruction-proof" ||
         evidence.operation !== "verify_reconstruction_obligations")
         return false;
     const result = evidence.normalized_result;
@@ -67,6 +67,6 @@ export const evidenceSupportsOriginalAuthority = (evidence, authority) => {
         return ["controlled-replay", "external-service"].includes(evidence.authority);
     if (authority === "process")
         return (evidence.operation === "capture_process_scenario" &&
-            evidence.predicate_type === "rea.process-capture/v4");
+            evidence.predicate_type === "rea.process-capture");
     return evidence.authority === "external-service";
 };

package/dist/application/ReconstructionObligationCandidates.js

@@ -73,7 +73,7 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
 };
 const deriveProcessCandidate = (evidence, candidates, limitations) => {
     if (evidence.operation !== "capture_process_scenario" ||
-        evidence.predicate_type !== "rea.process-capture/v4")
+        evidence.predicate_type !== "rea.process-capture")
         return;
     try {
         const capture = parseProcessCapture(evidence.normalized_result);
@@ -146,7 +146,7 @@ const deriveProcessCandidate = (evidence, candidates, limitations) => {
 const generatedCandidate = ({ key, title, policy: candidatePolicy, artifactSha256, applicationNodeId, semanticNodeId, location, authorityReferences, }) => ({
     obligation_id: obligationId(key),
     obligation_version: 1,
-    title: title.slice(0, 500),
+    title,
     origin: "generated",
     application_layer: candidatePolicy.applicationLayer,
     family: candidatePolicy.family,
@@ -218,7 +218,7 @@ const graphReference = (envelope, records, graphEvidence, location) => {
 };
 const reviewedEvidenceState = (evidence) => {
     if (evidence.operation === "capture_process_scenario" &&
-        evidence.predicate_type === "rea.process-capture/v4" &&
+        evidence.predicate_type === "rea.process-capture" &&
         evidence.confidence === "observed")
         return "observed";
     if (evidence.authority === "external-service" &&
@@ -255,7 +255,7 @@ const sourceState = (references) => {
     return "unknown";
 };
 const uniqueBy = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => key(left).localeCompare(key(right)));
-const obligationId = (key) => `obl_${digest({ schema: "rea.reconstruction-obligation/v1", key })}`;
+const obligationId = (key) => `obl_${digest({ schema: "ReconstructionObligation", key })}`;
 const digest = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/application/ReconstructionObligationLedgerEvaluation.js

@@ -4,12 +4,11 @@ import { evidenceAuthoritySupportsProof, evidenceSupportsOriginalAuthority, proo
 import { addObligationDiagnostic as addDiagnostic, contradictionDiagnostics, groupManifestBindings, groupManifestContradictions, hasObligationDiagnostic as hasDiagnostic, uniqueObligationDiagnostics as uniqueDiagnostics, } from "./ReconstructionObligationLedgerDiagnostics.js";
 import { originalCaseDiagnostics, originalCasesFor, } from "./ReconstructionObligationOriginalCases.js";
 import { digestObligationLedgerValue, obligationLedgerCoverage, obligationEdgeOrder, obligationLedgerEvidenceLinks, obligationLedgerStatus, obligationReports, summarizeObligations, } from "./ReconstructionObligationLedgerProjection.js";
-export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, maxObligations, generationLimitations, }) => {
+export const evaluateReconstructionObligationLedger = ({ candidates: candidatesInput, bundle: bundleInput, manifest, generationLimitations, }) => {
     const bundle = parseEvidenceBundle(bundleInput);
     const allCandidates = [...candidatesInput].sort((left, right) => left.obligation_id.localeCompare(right.obligation_id));
     const orphanManifestIds = findOrphanManifestIds(allCandidates, manifest);
-    const candidates = allCandidates.slice(0, maxObligations);
-    const omittedCount = allCandidates.length - candidates.length;
+    const candidates = allCandidates;
     const context = createEvaluationContext(candidates, bundle, manifest);
     const obligations = applyDependencyDiagnostics(candidates.map((candidate) => evaluateObligation(candidate, context)), context);
     const ownershipGraph = obligations
@@ -30,8 +29,8 @@ export const evaluateReconstructionObligationLedger = ({ candidates: candidatesI
     })))
         .sort(obligationEdgeOrder);
     const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);
-    const limitations = ledgerLimitations(generationLimitations, allCandidates.length, omittedCount, orphanManifestIds);
-    const coverage = obligationLedgerCoverage(omittedCount, maxObligations, limitations.length > 0);
+    const limitations = ledgerLimitations(generationLimitations, allCandidates.length, orphanManifestIds);
+    const coverage = obligationLedgerCoverage(limitations.length > 0);
     const semantic = {
         coverage,
         summary: summarizeObligations(obligations),
@@ -42,22 +41,21 @@ export const evaluateReconstructionObligationLedger = ({ candidates: candidatesI
         evidence_links: evidenceLinks,
         limitations,
     };
-    const evaluatedStatus = obligationLedgerStatus(obligations, omittedCount);
+    const evaluatedStatus = obligationLedgerStatus(obligations);
     const status = evaluatedStatus === "failed"
         ? evaluatedStatus
         : limitations.length > 0
             ? "unknown"
             : evaluatedStatus;
     const closureDigest = digestObligationLedgerValue({
-        schema: "rea.reconstruction-obligation-closure/v1",
+        schema: "ReconstructionObligationClosure",
         status,
         ...semantic,
     });
     return reconstructionObligationLedgerSchema.parse({
         schema: "ReconstructionObligationLedger",
-        schema_version: 1,
         ledger_id: `rol_${digestObligationLedgerValue({
-            schema: "rea.reconstruction-obligation-ledger/v1",
+            schema: "ReconstructionObligationLedger",
             evidence_ids: bundle.records.map(({ evidence_id: id }) => id),
             obligation_ids: obligations.map(({ obligation_id: id }) => id),
             closure_digest: closureDigest,
@@ -82,7 +80,7 @@ const findOrphanManifestIds = (candidates, manifest) => {
         ].filter((obligationId) => !candidateIds.has(obligationId))),
     ].sort();
 };
-const ledgerLimitations = (generationLimitations, candidateCount, omittedCount, orphanManifestIds) => [
+const ledgerLimitations = (generationLimitations, candidateCount, orphanManifestIds) => [
     ...new Set([
         ...generationLimitations,
         ...(candidateCount === 0
@@ -90,11 +88,6 @@ const ledgerLimitations = (generationLimitations, candidateCount, omittedCount,
                 "No reconstruction obligations were derived; closure cannot be claimed.",
             ]
             : []),
-        ...(omittedCount > 0
-            ? [
-                `${String(omittedCount)} obligation candidates were omitted by max_obligations; closure is unknown.`,
-            ]
-            : []),
         ...(orphanManifestIds.length > 0
             ? [
                 `Manifest entries reference unknown obligations: ${orphanManifestIds.join(", ")}.`,

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,10 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-export const obligationLedgerCoverage = (omittedCount, maxObligations, incomplete) => ({
+export const obligationLedgerCoverage = (incomplete) => ({
     status: incomplete ? "partial" : "complete",
-    truncated: omittedCount > 0,
-    omitted_count: omittedCount,
-    max_obligations: maxObligations,
 });
 export const summarizeObligations = (obligations) => ({
     total: obligations.length,
@@ -56,15 +53,14 @@ export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
         ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
     ]),
 ].sort();
-export const obligationLedgerStatus = (obligations, omittedCount) => {
+export const obligationLedgerStatus = (obligations) => {
     if (obligations.length === 0)
         return "unknown";
     const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
     if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
         hasDiagnostic(diagnostics, "verifier-failed")))
         return "failed";
-    if (omittedCount > 0 ||
-        requiredOpen.some(({ status }) => status === "unknown"))
+    if (requiredOpen.some(({ status }) => status === "unknown"))
         return "unknown";
     return requiredOpen.length === 0 ? "ready" : "open";
 };