morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #7338] [Bug] Optional obligation keeps a ledger ready despite a diagnosed unresolved Evidence reference #4360

New issue

Closed

opened 2026-10-31 00:49:12 +00:00 by bsakaguchi · 0 comments

bsakaguchi commented

2026-10-31 00:49:12 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 27, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/7338

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

Evidence, artifacts, or reconstruction

Observed behavior

The public build-reconstruction-obligation-ledger CLI reports status: "ready" when an optional reviewed obligation retains a fixture Evidence reference absent from its input bundle. The result correctly marks that obligation implemented and emits a missing-case diagnostic, yet retains the absent ID in both binding.fixtures and evidence_links while declaring the ledger ready.

Changing only the obligation's required flag to true returns open. Resolving the extra fixture's reference to the applicable proof already in the bundle returns ready with a verified obligation and no diagnostics for either requiredness setting. A further mixed-ledger check, containing a separately verified required obligation alongside the affected optional one, also returns ready with the dangling reference. This is not confined to ledgers with zero required obligations.

Reproduction

Prerequisites: the source baseline below, its locked dependencies, an already-built compiled runtime, and Node 24.22.1. The reproduction uses only synthetic Evidence and isolated configuration directories; the manifest command and owner path are descriptive data and never execute or open a target. No installation or build was performed during verification.

From the prepared checkout root, run the following. Each of the four variants ran once in the primary matrix and once again when the report's inline reproduction was replayed.

repo="$PWD"
work=$(mktemp -d)
mkdir -p "$work/home"
cat > "$work/generate.mjs" <<'JS'
import { writeFileSync } from 'node:fs';
import { resolve } from 'node:path';
import { pathToFileURL } from 'node:url';
const repo = resolve(process.argv[2]);
const out = resolve(process.argv[3]);
const { createEvidence } = await import(pathToFileURL(resolve(repo, 'dist/domain/evidence.js')));
const { createEvidenceBundle } = await import(pathToFileURL(resolve(repo, 'dist/domain/evidenceBundle.js')));
const provider = { id: 'synthetic', name: 'Synthetic fixture', version: '1' };
const id = 'review.reference-integrity';
const digest = '2'.repeat(64);
const original = createEvidence(undefined, provider, {
  operation: 'observe', parameters: {}, result: { value: 1 },
  confidence: 'observed', authority: 'shipped-artifact',
});
const proof = createEvidence(undefined, provider, {
  predicateType: 'rea.reconstruction-proof', operation: 'verify_reconstruction_obligations',
  parameters: {}, confidence: 'observed', authority: 'controlled-replay',
  result: { bindings: [{ obligation_id: id, obligation_version: 1, owner_sha256: digest,
    fixtures: [
      { fixture_id: 'fixture.positive', case_kind: 'positive', passed: true },
      { fixture_id: 'fixture.extra', case_kind: 'malformed', passed: true },
    ], verifiers: [{ verifier_id: 'verifier.sample', claim_id: 'claim.sample', passed: true }],
  }] },
});
const reviewed = {
  obligation_id: id, obligation_version: 1, title: 'Synthetic reference check',
  application_layer: 'other', family: 'sample',
  target: { artifact_sha256: null, application_node_id: null, semantic_node_id: null, location: 'sample' },
  required: false, required_case_kinds: ['positive'],
  required_original_authority: 'static', required_fixture_authority: 'unit', required_verifier_authority: 'unit',
  requires_parser_type: false, dependency_obligation_ids: [], residual_unknown_ids: [],
  unavailable_authority: [], required_next_evidence: [], disposition: 'active', review_evidence_ids: [original.evidence_id],
};
const absent = 'ev_' + 'c'.repeat(64);
const binding = {
  obligation_id: id, owner: { module_path: 'sample.ts', symbol: 'sample', owner_sha256: digest }, parser_type: null,
  original_cases: [{ kind: 'positive', evidence_id: original.evidence_id, location: '/normalized_result' }],
  fixtures: [
    { fixture_id: 'fixture.positive', case_kind: 'positive', authority: 'unit', evidence_ids: [proof.evidence_id] },
    { fixture_id: 'fixture.extra', case_kind: 'malformed', authority: 'unit', evidence_ids: [absent] },
  ],
  verifier: { verifier_id: 'verifier.sample', claim_id: 'claim.sample', command: 'node sample.mjs',
    authority: 'unit', status: 'pass', result_evidence_id: proof.evidence_id,
    enumerated_obligation_ids: [id], nondeterminism: { mode: 'total-order', specification: 'One assertion.' } },
};
for (const required of [false, true]) {
  for (const resolved of [false, true]) {
    const b = structuredClone(binding);
    if (resolved) b.fixtures[1].evidence_ids = [proof.evidence_id];
    const request = { evidence_bundle: createEvidenceBundle([original, proof]),
      reviewed_obligations: [{ ...reviewed, required }], manifest: { bindings: [b], contradictions: [] } };
    const name = `${required ? 'required' : 'optional'}-${resolved ? 'resolved' : 'missing'}`;
    writeFileSync(resolve(out, name + '.json'), JSON.stringify(request));
  }
}
writeFileSync(resolve(out, 'fixture-meta.json'), JSON.stringify({ absent, record_ids: [original.evidence_id, proof.evidence_id] }, null, 2));
JS
node "$work/generate.mjs" "$repo" "$work"
cd "$work"
for variant in optional-missing required-missing optional-resolved required-resolved; do
  env -i PATH="$PATH" HOME="$work/home" \
    XDG_CONFIG_HOME="$work/home/config" XDG_CACHE_HOME="$work/home/cache" NO_COLOR=1 \
    node "$repo/scripts/rea.mjs" build-reconstruction-obligation-ledger \
      "$work/$variant.json" --format json > "$work/$variant.stdout.json"
done
node --input-type=module <<'JS'
import { readFileSync } from 'node:fs';
for (const name of ['optional-missing', 'required-missing', 'optional-resolved', 'required-resolved']) {
  const request = JSON.parse(readFileSync(name + '.json'));
  const ledger = JSON.parse(readFileSync(name + '.stdout.json')).normalized_result;
  const records = new Set(request.evidence_bundle.records.map(r => r.evidence_id));
  console.log(JSON.stringify({ name, status: ledger.status,
    obligation: ledger.obligations[0].status,
    diagnostics: ledger.obligations[0].diagnostics.map(d => d.code),
    unresolved: ledger.evidence_links.filter(id => !records.has(id)) }));
}
JS

The resolved variants preserve the additional malformed fixture and change only its Evidence reference. The proof contains matching owner/revision bindings and passing outcomes for both fixture IDs and the verifier.

Expected behavior

docs/reconstruction-obligation-ledgers.md:334-336 explicitly makes resolution of every retained Evidence reference a prerequisite for a ready ledger, including references on optional case kinds. This global reference-integrity requirement applies separately from whether an obligation is required to be verified. Ordinary incomplete optional work need not block readiness, but a retained unresolved reference must prevent ready or cause a typed input rejection. The resolved controls should remain ready.

Impact and scope

A consumer relying on the ledger's ready status receives an affirmative result with incomplete provenance. The diagnostic remains available, so consumers checking it or resolving the links can detect the problem. Observed scope is one synthetic optional obligation, both alone and beside a verified required obligation. The primary matrix ran each of six variants once; a separate replay of the inline reproduction repeated the first four with the same results. Real-world frequency is NOT_ENOUGH_INFO because no production ledgers were examined. No Evidence loss, target execution or downstream incident was observed.

A demonstrated workaround is to correct the stale fixture reference to an applicable retained proof: both resolved controls are ready, verified and free of unresolved links. Restoring an omitted record is another possible input correction, but that variant was not run. Requiring an optional obligation also withheld readiness in the control, though that changes the declared closure scope.

REA version

6.8.0, source revision dbe2c97af34361b11b9504e37611dd47715b52cb. The CLI reported 6.8.0; the existing build receipt identifies this baseline.

Runtime and platform

Node.js v24.22.1; macOS 27.0.1 arm64. The public source-checkout CLI used the already-built runtime. No analysis provider or source loader was needed.

Target and artifact context

Two synthetic authenticated Evidence records: one shipped-artifact observation and one controlled-replay reconstruction proof. The manifest binds a static reviewed obligation, a positive fixture, an extra malformed fixture, and an owner/revision-bound verifier. The deliberately absent ID is ev_ followed by 64 c characters. No binary or application was inspected. The mixed-ledger control adds one independently applicable proof for a required companion obligation.

Interface

CLI

Earliest failure stage

Native analysis or reconstruction

Relevant output or evidence

All six primary public CLI invocations exited 0. The first four use the inline fixture; the final two add the verified required companion described above. A separate replay of the four inline cases also exited 0 and reproduced the same statuses and unresolved-reference counts.

Variant	Ledger status	Required / required open	Affected obligation	Diagnostics	Unresolved links
Optional, absent reference	ready	0 / 0	implemented	missing-case	1
Required, absent reference	open	1 / 1	implemented	missing-case	1
Optional, resolved reference	ready	0 / 0	verified	none	0
Required, resolved reference	ready	1 / 0	verified	none	0
Optional absent reference plus verified required companion	ready	1 / 0	implemented	missing-case	1
Optional resolved reference plus verified required companion	ready	1 / 0	verified	none	0

The actual diagnostic in every absent-reference result is:

{"code":"missing-case","detail":"malformed fixture fixture.extra references Evidence ev_cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc, which is absent from the bundle."}

The referenced fixture remains in the returned binding. Comparing evidence_links with the input bundle's record IDs finds exactly that absent ID. Every result has limitations: [] and coverage.status: "complete"; the demonstrated contract failure is the ready verdict. This report does not establish a separate coverage-status defect.

Typed outcome or recovery expected

Withhold ready or return a typed input error while this retained reference is unresolved. Preserve the missing-ID diagnostic and keep the resolved controls ready. This does not require making every incomplete optional obligation block ledger readiness.

Analysis or suspected cause

Source-derived: src/application/ReconstructionObligationLedgerEvaluation.ts:265-274 detects the missing fixture reference. src/application/ReconstructionObligationLedgerProjection.ts:9-25 retains it. The ledger limitations at src/application/ReconstructionObligationLedgerEvaluation.ts:157-176 do not include this integrity failure, and src/domain/reconstructionObligationLedgerIntegrity.ts:65-85 derives readiness from required obligations only. The final schema checks its own projections but has no input bundle against which to resolve links (src/domain/reconstructionObligationLedgerSchemas.ts:352-445). These branches explain the observed diagnostic without a non-ready aggregate status; no implementation change was attempted.

Additional context

Expected source: the explicit ready-ledger all-retained-reference requirement cited under Expected behavior. The accepted input schema allows required: false; no exception to the reference requirement is documented there.
Failure source: the independently executed public CLI matrix and exact diagnostic above, including the absent ID retained in the returned fixture and Evidence links.
Evidence provenance: observed public CLI results; the causal explanation is source-derived. The earlier candidate draft was a lead, not the source of the execution claims here.
Local verification: reproduced with fresh synthetic records and isolated HOME/XDG directories, one CLI process at a time. The prepared build receipt was supplied; the verifier did not rebuild the runtime.
Reproduction completeness: complete for the single-obligation public CLI case; its generator and all four request variants are inline. The two companion-obligation controls are supplemental observed evidence. MCP parity, other operating systems and a last-known-good version are NOT_ENOUGH_INFO because they were not exercised.
Restoration check: rerun the absent-reference optional case and require a non-ready result or typed rejection; retain the diagnostic if a ledger is returned. Resolve the reference while retaining the extra fixture and require ready, verified and no unresolved links. Repeat beside a verified required companion, and preserve the existing required-obligation missing-reference rejection. No fixed implementation was tested.

Related closed #6770 concerns surplus non-required case kinds whose missing-reference diagnostics were skipped; its required-obligation trigger now produces a diagnostic and an open ledger. Closed #3363, addressed by closed #3526, concerns a valid same-kind entry hiding an absent reference without a diagnostic. Here those diagnostics already work: the remaining signal is a ready aggregate with an explicitly diagnosed missing reference on an optional obligation. The required/optional control distinguishes the remaining aggregation gap from those completed validation cases. The related issue bodies and current discussions were read in full. The complete saved history, final live issue and pull-request searches, and recent reports contained no exact open duplicate of this remaining optional-obligation trigger.

Triage assessment

Impact level: P2
Assessment status: supported
Impact basis: The public CLI gives a ready ledger with an explicitly diagnosed unresolvable retained Evidence reference on an optional obligation, including beside a verified required obligation. This is a bounded result-integrity defect with visible diagnostics and no observed data loss or severe incident.
Workaround status: available
Workaround basis: Correcting the stale fixture reference to its applicable proof already in the bundle preserved the fixture and produced ready, verified obligations with no unresolved links in both single-obligation controls and the mixed-ledger control.

Originally created by @coygeek on GitHub (Oct 27, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/7338 ## Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ## Area Evidence, artifacts, or reconstruction ## Observed behavior The public `build-reconstruction-obligation-ledger` CLI reports `status: "ready"` when an optional reviewed obligation retains a fixture Evidence reference absent from its input bundle. The result correctly marks that obligation `implemented` and emits a `missing-case` diagnostic, yet retains the absent ID in both `binding.fixtures` and `evidence_links` while declaring the ledger ready. Changing only the obligation's `required` flag to `true` returns `open`. Resolving the extra fixture's reference to the applicable proof already in the bundle returns `ready` with a `verified` obligation and no diagnostics for either requiredness setting. A further mixed-ledger check, containing a separately verified required obligation alongside the affected optional one, also returns `ready` with the dangling reference. This is not confined to ledgers with zero required obligations. ## Reproduction Prerequisites: the source baseline below, its locked dependencies, an already-built compiled runtime, and Node 24.22.1. The reproduction uses only synthetic Evidence and isolated configuration directories; the manifest command and owner path are descriptive data and never execute or open a target. No installation or build was performed during verification. From the prepared checkout root, run the following. Each of the four variants ran once in the primary matrix and once again when the report's inline reproduction was replayed. ```sh repo="$PWD" work=$(mktemp -d) mkdir -p "$work/home" cat > "$work/generate.mjs" <<'JS' import { writeFileSync } from 'node:fs'; import { resolve } from 'node:path'; import { pathToFileURL } from 'node:url'; const repo = resolve(process.argv[2]); const out = resolve(process.argv[3]); const { createEvidence } = await import(pathToFileURL(resolve(repo, 'dist/domain/evidence.js'))); const { createEvidenceBundle } = await import(pathToFileURL(resolve(repo, 'dist/domain/evidenceBundle.js'))); const provider = { id: 'synthetic', name: 'Synthetic fixture', version: '1' }; const id = 'review.reference-integrity'; const digest = '2'.repeat(64); const original = createEvidence(undefined, provider, { operation: 'observe', parameters: {}, result: { value: 1 }, confidence: 'observed', authority: 'shipped-artifact', }); const proof = createEvidence(undefined, provider, { predicateType: 'rea.reconstruction-proof', operation: 'verify_reconstruction_obligations', parameters: {}, confidence: 'observed', authority: 'controlled-replay', result: { bindings: [{ obligation_id: id, obligation_version: 1, owner_sha256: digest, fixtures: [ { fixture_id: 'fixture.positive', case_kind: 'positive', passed: true }, { fixture_id: 'fixture.extra', case_kind: 'malformed', passed: true }, ], verifiers: [{ verifier_id: 'verifier.sample', claim_id: 'claim.sample', passed: true }], }] }, }); const reviewed = { obligation_id: id, obligation_version: 1, title: 'Synthetic reference check', application_layer: 'other', family: 'sample', target: { artifact_sha256: null, application_node_id: null, semantic_node_id: null, location: 'sample' }, required: false, required_case_kinds: ['positive'], required_original_authority: 'static', required_fixture_authority: 'unit', required_verifier_authority: 'unit', requires_parser_type: false, dependency_obligation_ids: [], residual_unknown_ids: [], unavailable_authority: [], required_next_evidence: [], disposition: 'active', review_evidence_ids: [original.evidence_id], }; const absent = 'ev_' + 'c'.repeat(64); const binding = { obligation_id: id, owner: { module_path: 'sample.ts', symbol: 'sample', owner_sha256: digest }, parser_type: null, original_cases: [{ kind: 'positive', evidence_id: original.evidence_id, location: '/normalized_result' }], fixtures: [ { fixture_id: 'fixture.positive', case_kind: 'positive', authority: 'unit', evidence_ids: [proof.evidence_id] }, { fixture_id: 'fixture.extra', case_kind: 'malformed', authority: 'unit', evidence_ids: [absent] }, ], verifier: { verifier_id: 'verifier.sample', claim_id: 'claim.sample', command: 'node sample.mjs', authority: 'unit', status: 'pass', result_evidence_id: proof.evidence_id, enumerated_obligation_ids: [id], nondeterminism: { mode: 'total-order', specification: 'One assertion.' } }, }; for (const required of [false, true]) { for (const resolved of [false, true]) { const b = structuredClone(binding); if (resolved) b.fixtures[1].evidence_ids = [proof.evidence_id]; const request = { evidence_bundle: createEvidenceBundle([original, proof]), reviewed_obligations: [{ ...reviewed, required }], manifest: { bindings: [b], contradictions: [] } }; const name = `${required ? 'required' : 'optional'}-${resolved ? 'resolved' : 'missing'}`; writeFileSync(resolve(out, name + '.json'), JSON.stringify(request)); } } writeFileSync(resolve(out, 'fixture-meta.json'), JSON.stringify({ absent, record_ids: [original.evidence_id, proof.evidence_id] }, null, 2)); JS node "$work/generate.mjs" "$repo" "$work" cd "$work" for variant in optional-missing required-missing optional-resolved required-resolved; do env -i PATH="$PATH" HOME="$work/home" \ XDG_CONFIG_HOME="$work/home/config" XDG_CACHE_HOME="$work/home/cache" NO_COLOR=1 \ node "$repo/scripts/rea.mjs" build-reconstruction-obligation-ledger \ "$work/$variant.json" --format json > "$work/$variant.stdout.json" done node --input-type=module <<'JS' import { readFileSync } from 'node:fs'; for (const name of ['optional-missing', 'required-missing', 'optional-resolved', 'required-resolved']) { const request = JSON.parse(readFileSync(name + '.json')); const ledger = JSON.parse(readFileSync(name + '.stdout.json')).normalized_result; const records = new Set(request.evidence_bundle.records.map(r => r.evidence_id)); console.log(JSON.stringify({ name, status: ledger.status, obligation: ledger.obligations[0].status, diagnostics: ledger.obligations[0].diagnostics.map(d => d.code), unresolved: ledger.evidence_links.filter(id => !records.has(id)) })); } JS ``` The resolved variants preserve the additional `malformed` fixture and change only its Evidence reference. The proof contains matching owner/revision bindings and passing outcomes for both fixture IDs and the verifier. ## Expected behavior `docs/reconstruction-obligation-ledgers.md:334-336` explicitly makes resolution of every retained Evidence reference a prerequisite for a ready ledger, including references on optional case kinds. This global reference-integrity requirement applies separately from whether an obligation is required to be verified. Ordinary incomplete optional work need not block readiness, but a retained unresolved reference must prevent `ready` or cause a typed input rejection. The resolved controls should remain ready. ## Impact and scope A consumer relying on the ledger's `ready` status receives an affirmative result with incomplete provenance. The diagnostic remains available, so consumers checking it or resolving the links can detect the problem. Observed scope is one synthetic optional obligation, both alone and beside a verified required obligation. The primary matrix ran each of six variants once; a separate replay of the inline reproduction repeated the first four with the same results. Real-world frequency is NOT_ENOUGH_INFO because no production ledgers were examined. No Evidence loss, target execution or downstream incident was observed. A demonstrated workaround is to correct the stale fixture reference to an applicable retained proof: both resolved controls are ready, verified and free of unresolved links. Restoring an omitted record is another possible input correction, but that variant was not run. Requiring an optional obligation also withheld readiness in the control, though that changes the declared closure scope. ## REA version 6.8.0, source revision `dbe2c97af34361b11b9504e37611dd47715b52cb`. The CLI reported `6.8.0`; the existing build receipt identifies this baseline. ## Runtime and platform Node.js v24.22.1; macOS 27.0.1 arm64. The public source-checkout CLI used the already-built runtime. No analysis provider or source loader was needed. ## Target and artifact context Two synthetic authenticated Evidence records: one shipped-artifact observation and one controlled-replay reconstruction proof. The manifest binds a static reviewed obligation, a positive fixture, an extra malformed fixture, and an owner/revision-bound verifier. The deliberately absent ID is `ev_` followed by 64 `c` characters. No binary or application was inspected. The mixed-ledger control adds one independently applicable proof for a required companion obligation. ## Interface CLI ## Earliest failure stage Native analysis or reconstruction ## Relevant output or evidence All six primary public CLI invocations exited 0. The first four use the inline fixture; the final two add the verified required companion described above. A separate replay of the four inline cases also exited 0 and reproduced the same statuses and unresolved-reference counts. | Variant | Ledger status | Required / required open | Affected obligation | Diagnostics | Unresolved links | |---|---|---|---|---|---| | Optional, absent reference | ready | 0 / 0 | implemented | missing-case | 1 | | Required, absent reference | open | 1 / 1 | implemented | missing-case | 1 | | Optional, resolved reference | ready | 0 / 0 | verified | none | 0 | | Required, resolved reference | ready | 1 / 0 | verified | none | 0 | | Optional absent reference plus verified required companion | ready | 1 / 0 | implemented | missing-case | 1 | | Optional resolved reference plus verified required companion | ready | 1 / 0 | verified | none | 0 | The actual diagnostic in every absent-reference result is: ```json {"code":"missing-case","detail":"malformed fixture fixture.extra references Evidence ev_cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc, which is absent from the bundle."} ``` The referenced fixture remains in the returned binding. Comparing `evidence_links` with the input bundle's record IDs finds exactly that absent ID. Every result has `limitations: []` and `coverage.status: "complete"`; the demonstrated contract failure is the `ready` verdict. This report does not establish a separate coverage-status defect. ## Typed outcome or recovery expected Withhold `ready` or return a typed input error while this retained reference is unresolved. Preserve the missing-ID diagnostic and keep the resolved controls ready. This does not require making every incomplete optional obligation block ledger readiness. ## Analysis or suspected cause Source-derived: `src/application/ReconstructionObligationLedgerEvaluation.ts:265-274` detects the missing fixture reference. `src/application/ReconstructionObligationLedgerProjection.ts:9-25` retains it. The ledger limitations at `src/application/ReconstructionObligationLedgerEvaluation.ts:157-176` do not include this integrity failure, and `src/domain/reconstructionObligationLedgerIntegrity.ts:65-85` derives readiness from required obligations only. The final schema checks its own projections but has no input bundle against which to resolve links (`src/domain/reconstructionObligationLedgerSchemas.ts:352-445`). These branches explain the observed diagnostic without a non-ready aggregate status; no implementation change was attempted. ## Additional context - Expected source: the explicit ready-ledger all-retained-reference requirement cited under Expected behavior. The accepted input schema allows `required: false`; no exception to the reference requirement is documented there. - Failure source: the independently executed public CLI matrix and exact diagnostic above, including the absent ID retained in the returned fixture and Evidence links. - Evidence provenance: observed public CLI results; the causal explanation is source-derived. The earlier candidate draft was a lead, not the source of the execution claims here. - Local verification: reproduced with fresh synthetic records and isolated HOME/XDG directories, one CLI process at a time. The prepared build receipt was supplied; the verifier did not rebuild the runtime. - Reproduction completeness: complete for the single-obligation public CLI case; its generator and all four request variants are inline. The two companion-obligation controls are supplemental observed evidence. MCP parity, other operating systems and a last-known-good version are NOT_ENOUGH_INFO because they were not exercised. - Restoration check: rerun the absent-reference optional case and require a non-ready result or typed rejection; retain the diagnostic if a ledger is returned. Resolve the reference while retaining the extra fixture and require ready, verified and no unresolved links. Repeat beside a verified required companion, and preserve the existing required-obligation missing-reference rejection. No fixed implementation was tested. Related closed [#6770](https://github.com/morluto/rea/issues/6770) concerns surplus non-required case kinds whose missing-reference diagnostics were skipped; its required-obligation trigger now produces a diagnostic and an open ledger. Closed [#3363](https://github.com/morluto/rea/issues/3363), addressed by closed [#3526](https://github.com/morluto/rea/pull/3526), concerns a valid same-kind entry hiding an absent reference without a diagnostic. Here those diagnostics already work: the remaining signal is a ready aggregate with an explicitly diagnosed missing reference on an optional obligation. The required/optional control distinguishes the remaining aggregation gap from those completed validation cases. The related issue bodies and current discussions were read in full. The complete saved history, final live issue and pull-request searches, and recent reports contained no exact open duplicate of this remaining optional-obligation trigger. ## Triage assessment - Impact level: P2 - Assessment status: supported - Impact basis: The public CLI gives a ready ledger with an explicitly diagnosed unresolvable retained Evidence reference on an optional obligation, including beside a verified required obligation. This is a bounded result-integrity defect with visible diagnostics and no observed data loss or severe incident. - Workaround status: available - Workaround basis: Correcting the stale fixture reference to its applicable proof already in the bundle preserved the fixture and produced ready, verified obligations with no unresolved links in both single-obligation controls and the mixed-ledger control.

bsakaguchi closed this issue

2026-10-31 00:49:13 +00:00

bsakaguchi referenced this issue

2026-10-31 01:12:39 +00:00

[PR #4360] [MERGED] perf(schema): reduce retained integer validator allocations #6201

bsakaguchi referenced this issue

2026-11-01 21:11:07 +00:00

[GH-ISSUE #5654] [Tracker] Open PRs that can't merge yet: conflicts and red CI (October 2026) #3425