musubix3 0.1.19 → 0.1.21

package/dist/packages/analysis/src/change-waiver.js

@@ -1,8 +1,9 @@
 import { error } from '../../domain/src/index.js';
 import { digest, exists, readText, within, writeJson } from './files.js';
-import { batchFor, batchForKey, batchKey, completenessTddUnsatisfiedCondition, designUnchangedCondition, effectiveBatches, greenUnprovenCondition, implementationUnchangedCondition, loadChangeEvidence, orderMigrationRequiredBatchCondition, orderMigrationRequiredPhaseCondition, orderMigrationRequiredRequirementCondition, phaseMissingCondition, recordMissingCondition, redUnprovenCondition, relevantImplementationUnchangedCondition, requirementsUnchangedCondition, testChangedAfterRedCondition, testsUnchangedCondition, } from './change-evidence.js';
-import { loadTddEvidence } from './tdd.js';
+import { batchFor, batchesForKey, batchKey, designUnchangedCondition, currentRequirementIdsForBatch, effectiveBatches, implementationUnchangedCondition, loadChangeEvidence, orderMigrationRequiredBatchCondition, orderMigrationRequiredPhaseCondition, phaseMissingCondition, phaseOrderBatchCondition, phaseOrderPhaseCondition, recordMissingCondition, relevantImplementationUnchangedCondition, requirementsUnchangedCondition, testChangedAfterRedCondition, testsUnchangedCondition, } from './change-evidence.js';
+import { loadTddEvidence, validlyVoidedTddCycles, validlyArchivedTddCycles, completenessTddUnsatisfiedCondition, greenUnprovenCondition, orderMigrationRequiredRequirementCondition, redUnprovenCondition, voidedCycleOrdersInCurrentWindow, } from './tdd.js';
 import { appendEvidenceOrder, evidenceOrderRecord, inspectEvidenceOrder } from './order.js';
+import { withEvidenceWriterLock } from './evidence-writer-lock.js';
 const WAIVER_PATH = '.musubix/evidence/change-waivers.json';
 const GENESIS_SHA256 = '0'.repeat(64);
 const SHA256_RE = /^[a-f0-9]{64}$/i;
@@ -24,6 +25,7 @@ export const WAIVABLE_CODES = [
     'CHANGE_IMPLEMENTATION_UNCHANGED',
     'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED',
     'CHANGE_TEST_CHANGED_AFTER_RED',
+    'CHANGE_PHASE_ORDER',
 ];
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-017
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-004 REQ-CHANGE-EVIDENCE-WAIVER-016
@@ -36,7 +38,7 @@ export const NEITHER_KEY_CODES = new Set(['CHANGE_REQUIREMENTS_UNCHANGED', 'CHAN
 export const REQUIREMENT_ONLY_CODES = new Set(['CHANGE_RED_UNPROVEN', 'CHANGE_GREEN_UNPROVEN', 'CHANGE_COMPLETENESS_TDD']);
 export const DETAIL_ONLY_CODES = new Set([
     'CHANGE_PHASE_MISSING', 'CHANGE_ORDER_MIGRATION_REQUIRED', 'CHANGE_TESTS_UNCHANGED',
-    'CHANGE_IMPLEMENTATION_UNCHANGED', 'CHANGE_TEST_CHANGED_AFTER_RED',
+    'CHANGE_IMPLEMENTATION_UNCHANGED', 'CHANGE_TEST_CHANGED_AFTER_RED', 'CHANGE_PHASE_ORDER',
 ]);
 export const BOTH_KEYS_CODES = new Set(['CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED']);
 /** Retained purely for backward-compatible naming inside this module. */
@@ -64,6 +66,49 @@ export function canonicalJson(value) {
     }
     return JSON.stringify(value) ?? 'null';
 }
+function changeRecordMissingApprovalNoteLines(changeId, waiverRecord) {
+    return [
+        'Code: CHANGE_RECORD_MISSING',
+        `Approver: ${waiverRecord.approver}`,
+        `Recorded at: ${waiverRecord.recordedAt}`,
+        `Snapshot hash: ${waiverRecord.snapshotHash}`,
+        'Files:',
+        `- .musubix/changes/${changeId}.md`,
+        '- .musubix/evidence/changes.json',
+        '- .musubix/evidence/order.json',
+    ];
+}
+function trimTrailingApprovalSeparator(prefix) {
+    if (prefix.endsWith('\r\n\r\n'))
+        return prefix.slice(0, -2);
+    if (prefix.endsWith('\n\n'))
+        return prefix.slice(0, -1);
+    return prefix;
+}
+/** @id CODE-CHANGE-EVIDENCE-WAIVER-026
+ * @implements REQ-CHANGE-EVIDENCE-WAIVER-011
+ * @design DES-CHANGE-EVIDENCE-WAIVER-002
+ */
+export function normalizeChangeRecordMissingDocument(text, changeId, waiverRecord) {
+    if (!waiverRecord || waiverRecord.code !== 'CHANGE_RECORD_MISSING')
+        return text;
+    const headings = [...text.matchAll(/^## [^\r\n]+$/gm)];
+    const lastHeading = headings.at(-1);
+    if (!lastHeading || lastHeading[0] !== '## Debt Remediation Approval' || lastHeading.index === undefined) {
+        return text;
+    }
+    const sectionStart = lastHeading.index;
+    const afterHeading = text.slice(sectionStart + lastHeading[0].length).replace(/^\r?\n/, '');
+    const nonBlankLines = afterHeading
+        .split(/\r?\n/)
+        .filter((line) => line.length > 0);
+    const expectedLines = changeRecordMissingApprovalNoteLines(changeId, waiverRecord);
+    if (nonBlankLines.length !== expectedLines.length)
+        return text;
+    if (!nonBlankLines.every((line, index) => line === expectedLines[index]))
+        return text;
+    return trimTrailingApprovalSeparator(text.slice(0, sectionStart));
+}
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-002
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-007
  * @design DES-CHANGE-EVIDENCE-WAIVER-001
@@ -76,7 +121,7 @@ export async function loadChangeWaiverEvidence(root) {
         if (value.schemaVersion !== 1 || !Array.isArray(value.waivers)) {
             return { schemaVersion: 1, waivers: [], malformed: true };
         }
-        return { schemaVersion: 1, waivers: value.waivers };
+        return { ...value, schemaVersion: 1, waivers: value.waivers };
     }
     catch {
         return { schemaVersion: 1, waivers: [], malformed: true };
@@ -114,8 +159,23 @@ export function diagnosticDetail(code, context) {
         || code === 'CHANGE_TEST_CHANGED_AFTER_RED' || code === 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED') {
         return context.batch !== undefined ? batchKey(context.batch.requirementIds) : undefined;
     }
+    if (code === 'CHANGE_PHASE_ORDER') {
+        if (context.batchPhaseName !== undefined && context.batch !== undefined) {
+            return `batch:${context.batchPhaseName}:${batchKey(context.batch.requirementIds)}`;
+        }
+        if (context.phaseName !== undefined)
+            return `phase:${context.phaseName}`;
+        return undefined;
+    }
     return undefined;
 }
+function validBatchKey(key) {
+    const ids = key.split(',');
+    return ids.length > 0
+        && ids.every((id) => id.length > 0)
+        && new Set(ids).size === ids.length
+        && batchKey(ids) === key;
+}
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-019
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-016
  * @design DES-CHANGE-EVIDENCE-WAIVER-002
@@ -125,31 +185,71 @@ export function diagnosticDetail(code, context) {
 export function parseDetail(code, detail) {
     if (detail === undefined)
         return null;
-    if (detail.startsWith('phase:'))
-        return { kind: 'phase', phaseName: detail.slice('phase:'.length) };
+    if (detail.startsWith('phase:')) {
+        const phaseName = detail.slice('phase:'.length);
+        const allowed = code === 'CHANGE_PHASE_MISSING'
+            ? ['impact', 'requirements', 'design', 'quality', ...tddBatchPhaseNames]
+            : code === 'CHANGE_ORDER_MIGRATION_REQUIRED'
+                ? ['impact', 'requirements', 'design']
+                : code === 'CHANGE_PHASE_ORDER'
+                    ? ['requirements', 'design']
+                    : [];
+        return allowed.includes(phaseName) ? { kind: 'phase', phaseName } : null;
+    }
     if (detail.startsWith('batch:')) {
+        if (code !== 'CHANGE_ORDER_MIGRATION_REQUIRED' && code !== 'CHANGE_PHASE_ORDER')
+            return null;
         const rest = detail.slice('batch:'.length);
         const separator = rest.indexOf(':');
         if (separator === -1)
             return null;
-        return { kind: 'batch', batchPhaseName: rest.slice(0, separator), batchKey: rest.slice(separator + 1) };
+        const batchPhaseName = rest.slice(0, separator);
+        const key = rest.slice(separator + 1);
+        const allowedBatchPhaseNames = code === 'CHANGE_PHASE_ORDER'
+            ? [...tddBatchPhaseNames, 'quality']
+            : tddBatchPhaseNames;
+        return allowedBatchPhaseNames.includes(batchPhaseName) && validBatchKey(key)
+            ? { kind: 'batch', batchPhaseName, batchKey: key }
+            : null;
+    }
+    if (detail.startsWith('requirement:')) {
+        if (code !== 'CHANGE_ORDER_MIGRATION_REQUIRED')
+            return null;
+        const parsedRequirementId = detail.slice('requirement:'.length);
+        return parsedRequirementId ? { kind: 'requirement', requirementId: parsedRequirementId } : null;
     }
-    if (detail.startsWith('requirement:'))
-        return { kind: 'requirement', requirementId: detail.slice('requirement:'.length) };
     if (code === 'CHANGE_TESTS_UNCHANGED' || code === 'CHANGE_IMPLEMENTATION_UNCHANGED'
         || code === 'CHANGE_TEST_CHANGED_AFTER_RED' || code === 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED') {
-        return { kind: 'batchKey', batchKey: detail };
+        return validBatchKey(detail) ? { kind: 'batchKey', batchKey: detail } : null;
     }
     return null;
 }
+function compareSnapshotCycles(left, right, orderOf, idOf, serializedOf) {
+    const rank = (value) => Number.isInteger(value) ? 0 : value === undefined || value === null ? 2 : 1;
+    const leftOrder = orderOf(left);
+    const rightOrder = orderOf(right);
+    const rankDifference = rank(leftOrder) - rank(rightOrder);
+    if (rankDifference !== 0)
+        return rankDifference;
+    if (Number.isInteger(leftOrder) && Number.isInteger(rightOrder) && leftOrder !== rightOrder) {
+        return leftOrder - rightOrder;
+    }
+    if (!Number.isInteger(leftOrder) && leftOrder != null && rightOrder != null) {
+        const orderComparison = canonicalJson(leftOrder).localeCompare(canonicalJson(rightOrder));
+        if (orderComparison !== 0)
+            return orderComparison;
+    }
+    const idComparison = (idOf(left) ?? '').localeCompare(idOf(right) ?? '');
+    if (idComparison !== 0)
+        return idComparison;
+    return canonicalJson(serializedOf(left)).localeCompare(canonicalJson(serializedOf(right)));
+}
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-004
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-011 REQ-CHANGE-EVIDENCE-WAIVER-016
  * @design DES-CHANGE-EVIDENCE-WAIVER-002
  */
-export async function snapshotPayload(root, evidence, tdd, order, changeId, code, requirementId, detail) {
+export async function snapshotPayload(root, evidence, tdd, order, changeId, code, requirementId, detail, waiverRecord) {
     const changePath = `.musubix/changes/${changeId}.md`;
-    if (!await exists(within(root, changePath)))
-        return null;
     const change = evidence?.changes.find((entry) => entry.changeId === changeId);
     if (code === 'CHANGE_REQUIREMENTS_UNCHANGED') {
         const impact = change?.phases.impact;
@@ -169,8 +269,11 @@ export async function snapshotPayload(root, evidence, tdd, order, changeId, code
         };
     }
     if (code === 'CHANGE_RECORD_MISSING') {
+        if (!await exists(within(root, changePath)))
+            return null;
+        const documentText = await readText(root, changePath);
         return {
-            documentDigest: digest(await readText(root, changePath)),
+            documentDigest: digest(normalizeChangeRecordMissingDocument(documentText, changeId, waiverRecord)),
             everRecorded: [...order.records.values()].some((record) => record.kind === 'change' && record.entityId === changeId && record.phase !== 'waiver'),
             currentEntry: change ? digest(canonicalJson(change)) : null,
         };
@@ -184,23 +287,25 @@ export async function snapshotPayload(root, evidence, tdd, order, changeId, code
             .filter((cycle) => cycle.requirementId === requirementId)
             .map((cycle) => ({
             cycleId: cycle.cycleId ?? '',
-            red: { valid: cycle.red.valid, order: cycle.red.order ?? null },
-            green: cycle.green ? { valid: cycle.green.valid, order: cycle.green.order ?? null } : null,
+            red: { valid: cycle.red.valid, order: cycle.red.order },
+            green: cycle.green ? { valid: cycle.green.valid, order: cycle.green.order } : null,
         }))
-            .sort((a, b) => {
-            const orderA = a.red.order ?? Number.MAX_SAFE_INTEGER;
-            const orderB = b.red.order ?? Number.MAX_SAFE_INTEGER;
-            if (orderA !== orderB)
-                return orderA - orderB;
-            return a.cycleId < b.cycleId ? -1 : a.cycleId > b.cycleId ? 1 : 0;
-        })
-            .map(({ cycleId: _cycleId, ...rest }) => rest);
+            .sort((a, b) => compareSnapshotCycles(a, b, (item) => item.red.order, (item) => item.cycleId, ({ cycleId: _id, ...item }) => item))
+            .map(({ cycleId: _cycleId, ...rest }) => ({
+            red: { valid: rest.red.valid, order: rest.red.order ?? null },
+            green: rest.green ? { valid: rest.green.valid, order: rest.green.order ?? null } : null,
+        }));
+        const validlyVoided = validlyVoidedTddCycles(tdd, order);
+        const voidedCycleOrders = change
+            ? voidedCycleOrdersInCurrentWindow(change, requirementId, tdd, validlyVoided)
+            : [];
         return {
             requirementsOrder: change?.phases.requirements?.order ?? null,
             red: phaseItem(batch?.red),
             implementation: phaseItem(batch?.implementation),
             green: phaseItem(batch?.green),
             cycles,
+            ...(voidedCycleOrders.length ? { voidedCycleOrders } : {}),
         };
     }
     const parsed = parseDetail(code, detail);
@@ -236,41 +341,118 @@ export async function snapshotPayload(root, evidence, tdd, order, changeId, code
             };
         }
         if (parsed.kind === 'batch') {
-            const batch = change ? batchForKey(effectiveBatches(change), parsed.batchKey) : undefined;
-            const item = batch?.[parsed.batchPhaseName];
-            return {
-                phaseItemPresent: item != null,
-                orderIsInteger: Number.isInteger(item?.order),
-                phaseOrder: Number.isInteger(item?.order) ? item.order : null,
+            const matches = change ? batchesForKey(effectiveBatches(change), parsed.batchKey) : [];
+            const state = (batch) => {
+                const item = batch?.[parsed.batchPhaseName];
+                return {
+                    phaseItemPresent: item != null,
+                    orderIsInteger: Number.isInteger(item?.order),
+                    phaseOrder: Number.isInteger(item?.order) ? item.order : null,
+                };
             };
+            return matches.length <= 1 ? state(matches[0]) : { matchingBatches: matches.map((batch) => state(batch)) };
         }
         if (parsed.kind === 'requirement') {
+            const validlyVoided = validlyVoidedTddCycles(tdd, order);
             const cycles = (tdd?.cycles ?? [])
                 .filter((cycle) => cycle.requirementId === parsed.requirementId)
-                .map((cycle) => ({ redOrder: cycle.red.order ?? null, greenOrder: cycle.green?.order ?? null }))
-                .sort((a, b) => (a.redOrder ?? Number.MAX_SAFE_INTEGER) - (b.redOrder ?? Number.MAX_SAFE_INTEGER));
-            return { cycles };
+                .map((cycle) => ({ cycleId: cycle.cycleId ?? '', redOrder: cycle.red.order, greenOrder: cycle.green?.order }))
+                .sort((a, b) => compareSnapshotCycles(a, b, (item) => item.redOrder, (item) => item.cycleId, ({ cycleId: _id, ...item }) => item))
+                .map(({ cycleId: _cycleId, redOrder, greenOrder }) => ({
+                redOrder: redOrder ?? null,
+                greenOrder: greenOrder ?? null,
+            }));
+            const voidedCycleOrders = change
+                ? voidedCycleOrdersInCurrentWindow(change, parsed.requirementId, tdd, validlyVoided)
+                : [];
+            return { cycles, ...(voidedCycleOrders.length ? { voidedCycleOrders } : {}) };
+        }
+        return null;
+    }
+    if (code === 'CHANGE_PHASE_ORDER') {
+        if (parsed.kind === 'phase') {
+            const laterItem = change?.phases[parsed.phaseName];
+            const earlierPhaseName = parsed.phaseName === 'requirements' ? 'impact' : 'requirements';
+            const earlierItem = change?.phases[earlierPhaseName];
+            return {
+                firstOrder: Number.isInteger(earlierItem?.order) ? earlierItem.order : null,
+                secondOrder: Number.isInteger(laterItem?.order) ? laterItem.order : null,
+            };
+        }
+        if (parsed.kind === 'batch') {
+            const matches = change ? batchesForKey(effectiveBatches(change), parsed.batchKey) : [];
+            const state = (batch) => {
+                const batchPhaseName = parsed.batchPhaseName;
+                const earlierItem = batchPhaseName === 'red' ? change?.phases.design
+                    : batchPhaseName === 'implementation' ? batch?.red
+                        : batchPhaseName === 'green' ? batch?.implementation
+                            : batch?.green;
+                const laterItem = batchPhaseName === 'quality' ? change?.phases.quality : batch?.[batchPhaseName];
+                return {
+                    firstOrder: Number.isInteger(earlierItem?.order) ? earlierItem.order : null,
+                    secondOrder: Number.isInteger(laterItem?.order) ? laterItem.order : null,
+                };
+            };
+            return matches.length <= 1 ? state(matches[0]) : { matchingBatches: matches.map((batch) => state(batch)) };
         }
         return null;
     }
     if (parsed.kind !== 'batchKey')
         return null;
-    const batch = change ? batchForKey(effectiveBatches(change), parsed.batchKey) : undefined;
+    const batches = change ? effectiveBatches(change) : [];
+    const matches = batchesForKey(batches, parsed.batchKey);
+    const batch = matches[0];
     if (code === 'CHANGE_TESTS_UNCHANGED') {
-        return { designTests: change?.phases.design?.fingerprints.tests ?? null, batchRedTests: batch?.red?.fingerprints.tests ?? null };
+        const designTests = change?.phases.design?.fingerprints.tests ?? null;
+        if (matches.length <= 1)
+            return { designTests, batchRedTests: batch?.red?.fingerprints.tests ?? null };
+        return {
+            designTests,
+            matchingBatches: matches.map((candidate) => ({
+                ownedRequirementIds: change ? currentRequirementIdsForBatch(batches, candidate, change.requirementIds).sort() : [],
+                batchRedTests: candidate.red?.fingerprints.tests ?? null,
+            })),
+        };
     }
     if (code === 'CHANGE_IMPLEMENTATION_UNCHANGED') {
+        if (matches.length > 1) {
+            return {
+                matchingBatches: matches.map((candidate) => ({
+                    ownedRequirementIds: change ? currentRequirementIdsForBatch(batches, candidate, change.requirementIds).sort() : [],
+                    redImplementation: candidate.red?.fingerprints.implementation ?? null,
+                    implementationImplementation: candidate.implementation?.fingerprints.implementation ?? null,
+                })),
+            };
+        }
         return {
             redImplementation: batch?.red?.fingerprints.implementation ?? null,
             implementationImplementation: batch?.implementation?.fingerprints.implementation ?? null,
         };
     }
     if (code === 'CHANGE_TEST_CHANGED_AFTER_RED') {
+        if (matches.length > 1) {
+            return {
+                matchingBatches: matches.map((candidate) => ({
+                    ownedRequirementIds: change ? currentRequirementIdsForBatch(batches, candidate, change.requirementIds).sort() : [],
+                    redTests: candidate.red?.fingerprints.tests ?? null,
+                    greenTests: candidate.green?.fingerprints.tests ?? null,
+                })),
+            };
+        }
         return { redTests: batch?.red?.fingerprints.tests ?? null, greenTests: batch?.green?.fingerprints.tests ?? null };
     }
     if (code === 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED') {
         if (requirementId === undefined)
             return null;
+        if (matches.length > 1) {
+            return {
+                matchingBatches: matches.map((candidate) => ({
+                    ownedRequirementIds: change ? currentRequirementIdsForBatch(batches, candidate, change.requirementIds).sort() : [],
+                    redRequirementImplementation: candidate.red?.fingerprints.requirementImplementations?.[requirementId] ?? null,
+                    implementationRequirementImplementation: candidate.implementation?.fingerprints.requirementImplementations?.[requirementId] ?? null,
+                })),
+            };
+        }
         return {
             redRequirementImplementation: batch?.red?.fingerprints.requirementImplementations?.[requirementId] ?? null,
             implementationRequirementImplementation: batch?.implementation?.fingerprints.requirementImplementations?.[requirementId] ?? null,
@@ -328,7 +510,7 @@ export function waiverChainValid(waivers, index) {
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-006 REQ-CHANGE-EVIDENCE-WAIVER-016
  * @design DES-CHANGE-EVIDENCE-WAIVER-002
  */
-export async function waiverLinkage(root, evidence, order, waivers, index) {
+export function waiverLinkage(order, waivers, index) {
     const record = waivers[index];
     if (!record)
         return { valid: false, reason: 'Waiver record does not exist.' };
@@ -336,9 +518,6 @@ export async function waiverLinkage(root, evidence, order, waivers, index) {
         return { valid: false, reason: 'Waiver record has an invalid shape.' };
     if (!waiverChainValid(waivers, index))
         return { valid: false, reason: 'Waiver record breaks the evidence chain.' };
-    if (!await exists(within(root, `.musubix/changes/${record.changeId}.md`))) {
-        return { valid: false, reason: `${record.changeId} has no change document.` };
-    }
     if (!WAIVABLE_CODES.includes(record.code)) {
         return { valid: false, reason: `${record.code} is not a waivable code.` };
     }
@@ -349,20 +528,11 @@ export async function waiverLinkage(root, evidence, order, waivers, index) {
     if (requiresDetail(code) !== (record.detail !== undefined)) {
         return { valid: false, reason: `${code}'s detail scope does not match its regime.` };
     }
-    if (code === 'CHANGE_RECORD_MISSING') {
-        const stillMissing = evidence === null || !evidence.changes.some((entry) => entry.changeId === record.changeId);
-        if (!stillMissing)
-            return { valid: false, reason: `${record.changeId} now has a chronology record.` };
-    }
-    else {
-        if (evidence === null)
-            return { valid: false, reason: 'No change evidence is available to link this waiver.' };
-        const change = evidence.changes.find((entry) => entry.changeId === record.changeId);
-        if (!change)
-            return { valid: false, reason: `${record.changeId} is not a known change.` };
-        if (record.requirementId !== undefined && !change.requirementIds.includes(record.requirementId)) {
-            return { valid: false, reason: `${record.requirementId} is not declared by ${record.changeId}.` };
-        }
+    if (record.detail !== undefined && !parseDetail(code, record.detail)) {
+        return { valid: false, reason: `${record.detail} is not valid detail grammar for ${code}.` };
+    }
+    if (waivers.filter((candidate) => candidate.order === record.order).length !== 1) {
+        return { valid: false, reason: `Waiver order ${record.order} is claimed by more than one record.` };
     }
     if (!order.valid)
         return { valid: false, reason: 'Monotonic evidence order is invalid.' };
@@ -377,6 +547,100 @@ export async function waiverLinkage(root, evidence, order, waivers, index) {
     }
     return { valid: true };
 }
+export async function evaluateWaiverCondition(root, evidence, tdd, order, scope) {
+    const change = evidence?.changes.find((entry) => entry.changeId === scope.changeId);
+    if (scope.code === 'CHANGE_RECORD_MISSING') {
+        if (!await exists(within(root, `.musubix/changes/${scope.changeId}.md`)))
+            return 'indeterminate';
+        return await recordMissingCondition(root, evidence, scope.changeId) ? 'true' : 'false';
+    }
+    if (!change)
+        return 'indeterminate';
+    if (scope.requirementId !== undefined && !change.requirementIds.includes(scope.requirementId))
+        return 'indeterminate';
+    const validlyVoided = validlyVoidedTddCycles(tdd, order);
+    // Issue #64 / REQ-CHANGE-EVIDENCE-WAIVER-018: mirror the gate's exclusion
+    // of validly archived cycles so a waiver's "is this condition still true"
+    // re-check never disagrees with validateChangeEvidence.
+    const validlyArchived = validlyArchivedTddCycles(tdd, order);
+    const result = (value) => value ? 'true' : 'false';
+    switch (scope.code) {
+        case 'CHANGE_REQUIREMENTS_UNCHANGED':
+            return result(requirementsUnchangedCondition(change));
+        case 'CHANGE_DESIGN_UNCHANGED':
+            return result(designUnchangedCondition(change));
+        case 'CHANGE_RED_UNPROVEN':
+            return result(!change.qualityHistory?.length
+                && redUnprovenCondition(change, scope.requirementId, tdd, validlyVoided));
+        case 'CHANGE_GREEN_UNPROVEN':
+            return result(!change.qualityHistory?.length
+                && greenUnprovenCondition(change, scope.requirementId, tdd, validlyVoided));
+        case 'CHANGE_COMPLETENESS_TDD':
+            return result(completenessTddUnsatisfiedCondition(change, scope.requirementId, tdd, validlyVoided));
+        default:
+            break;
+    }
+    const parsed = parseDetail(scope.code, scope.detail);
+    if (!parsed)
+        return 'indeterminate';
+    if (scope.code === 'CHANGE_PHASE_MISSING') {
+        return parsed.kind === 'phase' ? result(phaseMissingCondition(change, parsed.phaseName)) : 'indeterminate';
+    }
+    if (scope.code === 'CHANGE_ORDER_MIGRATION_REQUIRED') {
+        if (parsed.kind === 'phase')
+            return result(orderMigrationRequiredPhaseCondition(change, parsed.phaseName));
+        if (parsed.kind === 'requirement') {
+            if (!change.requirementIds.includes(parsed.requirementId))
+                return 'indeterminate';
+            return result(orderMigrationRequiredRequirementCondition(change, parsed.requirementId, tdd, validlyVoided, validlyArchived));
+        }
+        if (parsed.kind === 'batch') {
+            const matches = batchesForKey(effectiveBatches(change), parsed.batchKey);
+            if (!matches.length)
+                return 'indeterminate';
+            return result(orderMigrationRequiredBatchCondition(change, parsed.batchPhaseName, parsed.batchKey));
+        }
+        return 'indeterminate';
+    }
+    if (scope.code === 'CHANGE_PHASE_ORDER') {
+        if (parsed.kind === 'phase')
+            return result(phaseOrderPhaseCondition(change, parsed.phaseName));
+        if (parsed.kind === 'batch') {
+            const matches = batchesForKey(effectiveBatches(change), parsed.batchKey);
+            if (!matches.length)
+                return 'indeterminate';
+            return result(phaseOrderBatchCondition(change, parsed.batchPhaseName, parsed.batchKey));
+        }
+        return 'indeterminate';
+    }
+    if (parsed.kind !== 'batchKey')
+        return 'indeterminate';
+    const batches = effectiveBatches(change);
+    const matches = batchesForKey(batches, parsed.batchKey);
+    if (!matches.length)
+        return 'indeterminate';
+    const owned = matches.filter((batch) => {
+        const requirementIds = currentRequirementIdsForBatch(batches, batch, change.requirementIds);
+        return scope.code === 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED'
+            ? scope.requirementId !== undefined && requirementIds.includes(scope.requirementId)
+            : requirementIds.length > 0;
+    });
+    if (!owned.length)
+        return 'false';
+    if (scope.code === 'CHANGE_TESTS_UNCHANGED') {
+        return result(owned.some((batch) => testsUnchangedCondition(change, batch)));
+    }
+    if (scope.code === 'CHANGE_IMPLEMENTATION_UNCHANGED') {
+        return result(owned.some((batch) => implementationUnchangedCondition(batch)));
+    }
+    if (scope.code === 'CHANGE_TEST_CHANGED_AFTER_RED') {
+        return result(owned.some((batch) => testChangedAfterRedCondition(batch)));
+    }
+    if (scope.code === 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED') {
+        return result(owned.some((batch) => relevantImplementationUnchangedCondition(batch, scope.requirementId)));
+    }
+    return 'indeterminate';
+}
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-020
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-006 REQ-CHANGE-EVIDENCE-WAIVER-007 REQ-CHANGE-EVIDENCE-WAIVER-010 REQ-CHANGE-EVIDENCE-WAIVER-011
  * @design DES-CHANGE-EVIDENCE-WAIVER-004
@@ -384,28 +648,45 @@ export async function waiverLinkage(root, evidence, order, waivers, index) {
  * consults only this fully resolved value, so no diagnostic-emission call
  * site or final malformed/stale pass needs to itself `await` anything.
  */
-export async function buildWaiverContext(root, evidence, tdd) {
-    const loaded = await loadChangeWaiverEvidence(root);
-    const order = await inspectEvidenceOrder(root);
+export async function buildWaiverContext(root, evidence, tdd, precomputed = {}) {
+    const loaded = precomputed.loaded !== undefined ? precomputed.loaded : await loadChangeWaiverEvidence(root);
+    const order = precomputed.order ?? await inspectEvidenceOrder(root);
     const linkage = [];
     const currentHash = [];
+    const condition = [];
     if (loaded && !loaded.malformed) {
         for (let index = 0; index < loaded.waivers.length; index++) {
-            const recordLinkage = await waiverLinkage(root, evidence, order, loaded.waivers, index);
+            const recordLinkage = waiverLinkage(order, loaded.waivers, index);
             linkage.push(recordLinkage);
             if (recordLinkage.valid) {
                 const record = loaded.waivers[index];
-                currentHash.push(digest(canonicalJson(await snapshotPayload(root, evidence, tdd, order, record.changeId, record.code, record.requirementId, record.detail))));
+                currentHash.push(digest(canonicalJson(await snapshotPayload(root, evidence, tdd, order, record.changeId, record.code, record.requirementId, record.detail, record))));
+                condition.push(await evaluateWaiverCondition(root, evidence, tdd, order, {
+                    changeId: record.changeId,
+                    code: record.code,
+                    ...(record.requirementId !== undefined ? { requirementId: record.requirementId } : {}),
+                    ...(record.detail !== undefined ? { detail: record.detail } : {}),
+                }));
             }
             else {
                 currentHash.push(undefined);
+                condition.push(undefined);
             }
         }
     }
-    return { loaded, order, linkage, currentHash };
+    return { loaded, order, linkage, currentHash, condition };
 }
-function nonStale(record, index, waiverContext) {
-    return record.snapshotVersion === CURRENT_SNAPSHOT_VERSION && record.snapshotHash === waiverContext.currentHash[index];
+export function isWaiverStale(waiverContext, index) {
+    const loaded = waiverContext.loaded;
+    if (!loaded || loaded.malformed)
+        return true;
+    const record = loaded.waivers[index];
+    return !record
+        || record.snapshotVersion !== CURRENT_SNAPSHOT_VERSION
+        || record.snapshotHash !== waiverContext.currentHash[index]
+        || waiverContext.condition[index] === 'false'
+        || waiverContext.condition[index] === 'indeterminate'
+        || waiverContext.condition[index] === undefined;
 }
 function scopeMatches(record, changeId, code, requirementId, detail) {
     return record.changeId === changeId && record.code === code && record.requirementId === requirementId && record.detail === detail;
@@ -415,7 +696,7 @@ function scopeMatches(record, changeId, code, requirementId, detail) {
  * `changeId`/`code`/`requirementId`/`detail` scope group (REQ-006's
  * supersession rule), returning its index, or -1 if none match/link.
  */
-function authoritativeIndex(waiverContext, changeId, code, requirementId, detail) {
+export function authoritativeWaiverIndex(waiverContext, scope) {
     const loaded = waiverContext.loaded;
     if (!loaded || loaded.malformed)
         return -1;
@@ -424,7 +705,7 @@ function authoritativeIndex(waiverContext, changeId, code, requirementId, detail
         const record = loaded.waivers[index];
         if (!waiverContext.linkage[index]?.valid)
             continue;
-        if (!scopeMatches(record, changeId, code, requirementId, detail))
+        if (!scopeMatches(record, scope.changeId, scope.code, scope.requirementId, scope.detail))
             continue;
         if (best === -1 || record.order > loaded.waivers[best].order)
             best = index;
@@ -440,11 +721,16 @@ export function waivedDiagnostic(waiverContext, code, message, changeId, require
     const loaded = waiverContext.loaded;
     if (!loaded || loaded.malformed)
         return base;
-    const index = authoritativeIndex(waiverContext, changeId, code, requirementId, detail);
+    const index = authoritativeWaiverIndex(waiverContext, {
+        changeId,
+        code,
+        ...(requirementId !== undefined ? { requirementId } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+    });
     if (index === -1)
         return base;
     const record = loaded.waivers[index];
-    if (!nonStale(record, index, waiverContext))
+    if (isWaiverStale(waiverContext, index))
         return base;
     return {
         ...base,
@@ -456,7 +742,7 @@ export function waivedDiagnostic(waiverContext, code, message, changeId, require
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-006 REQ-CHANGE-EVIDENCE-WAIVER-007 REQ-CHANGE-EVIDENCE-WAIVER-011
  * @design DES-CHANGE-EVIDENCE-WAIVER-004
  */
-export function reportWaiverEvidenceDiagnostics(waiverContext, _evidence, _tdd) {
+export function reportWaiverEvidenceDiagnostics(waiverContext) {
     const loaded = waiverContext.loaded;
     if (!loaded)
         return [];
@@ -477,12 +763,29 @@ export function reportWaiverEvidenceDiagnostics(waiverContext, _evidence, _tdd)
         if (groupsSeen.has(scopeKey))
             continue;
         groupsSeen.add(scopeKey);
-        const authoritative = authoritativeIndex(waiverContext, record.changeId, record.code, record.requirementId, record.detail);
+        const authoritative = authoritativeWaiverIndex(waiverContext, {
+            changeId: record.changeId,
+            code: record.code,
+            ...(record.requirementId !== undefined ? { requirementId: record.requirementId } : {}),
+            ...(record.detail !== undefined ? { detail: record.detail } : {}),
+        });
         if (authoritative === -1)
             continue;
         const authoritativeRecord = loaded.waivers[authoritative];
-        if (!nonStale(authoritativeRecord, authoritative, waiverContext)) {
-            diagnostics.push(error('CHANGE_WAIVER_STALE', `Waiver for ${label(authoritativeRecord)} is stale.`, WAIVER_PATH));
+        if (isWaiverStale(waiverContext, authoritative)) {
+            const condition = waiverContext.condition[authoritative];
+            const remediation = condition === 'false'
+                ? 'The target code is no longer reported for this scope (condition=false); a replacement waiver is not required.'
+                : condition === 'true'
+                    ? 'The waived condition still exists (condition=true); resolve the debt or record an allowed replacement waiver.'
+                    : 'The waived condition cannot be evaluated; restore an evaluable change, requirement, or batch scope before retrying.';
+            diagnostics.push({
+                ...error('CHANGE_WAIVER_STALE', `Waiver for ${label(authoritativeRecord)} is stale. ${remediation}`, WAIVER_PATH),
+                severity: condition === 'false' ? 'warning' : 'error',
+                changeId: authoritativeRecord.changeId,
+                ...(authoritativeRecord.requirementId !== undefined ? { requirementId: authoritativeRecord.requirementId } : {}),
+                ...(authoritativeRecord.detail !== undefined ? { detail: authoritativeRecord.detail } : {}),
+            });
         }
     }
     return diagnostics;
@@ -492,6 +795,9 @@ export function reportWaiverEvidenceDiagnostics(waiverContext, _evidence, _tdd)
  * @design DES-CHANGE-EVIDENCE-WAIVER-001
  */
 export async function recordChangeWaiver(root, changeId, code, requirementId, detail, approver, reason) {
+    return withEvidenceWriterLock(root, 'change waiver record', () => recordChangeWaiverUnlocked(root, changeId, code, requirementId, detail, approver, reason));
+}
+async function recordChangeWaiverUnlocked(root, changeId, code, requirementId, detail, approver, reason) {
     const loaded = await loadChangeWaiverEvidence(root);
     const existing = loaded === null ? { schemaVersion: 1, waivers: [] } : loaded;
     if (loaded !== null && loaded.malformed) {
@@ -502,7 +808,7 @@ export async function recordChangeWaiver(root, changeId, code, requirementId, de
     for (let index = 0; index < existing.waivers.length; index++) {
         if (!waiverRecordShapeValid(existing.waivers[index])
             || !waiverChainValid(existing.waivers, index)
-            || !(await waiverLinkage(root, evidence, order, existing.waivers, index)).valid) {
+            || !waiverLinkage(order, existing.waivers, index).valid) {
             throw new Error('An existing waiver record is invalid; repair the evidence chain before recording a new waiver.');
         }
     }
@@ -523,82 +829,35 @@ export async function recordChangeWaiver(root, changeId, code, requirementId, de
     if (!approver.trim() || !reason.trim()) {
         throw new Error('A non-empty --approver and --reason are required.');
     }
-    if (!await exists(within(root, `.musubix/changes/${changeId}.md`))) {
-        throw new Error(`${changeId} has no change document.`);
-    }
-    const change = evidence?.changes.find((entry) => entry.changeId === changeId);
-    if (waivableCode !== 'CHANGE_RECORD_MISSING') {
-        if (!change)
-            throw new Error(`${changeId} is not a known change.`);
-        if (requirementId !== undefined && !change.requirementIds.includes(requirementId)) {
-            throw new Error(`${requirementId} is not declared by ${changeId}.`);
-        }
-    }
     const tdd = await loadTddEvidence(root);
     const parsed = detail !== undefined ? parseDetail(waivableCode, detail) : null;
     if (requiresDetail(waivableCode) && !parsed) {
         throw new Error(`${detail} is not a valid --detail value for ${waivableCode}.`);
     }
-    const currentlyReported = await (async () => {
-        switch (waivableCode) {
-            case 'CHANGE_REQUIREMENTS_UNCHANGED': return requirementsUnchangedCondition(change);
-            case 'CHANGE_DESIGN_UNCHANGED': return designUnchangedCondition(change);
-            case 'CHANGE_RED_UNPROVEN': return redUnprovenCondition(change, requirementId, tdd);
-            case 'CHANGE_GREEN_UNPROVEN': return greenUnprovenCondition(change, requirementId, tdd);
-            case 'CHANGE_COMPLETENESS_TDD': return completenessTddUnsatisfiedCondition(change, requirementId, tdd);
-            case 'CHANGE_RECORD_MISSING': return recordMissingCondition(root, evidence, changeId);
-            case 'CHANGE_PHASE_MISSING':
-                return parsed?.kind === 'phase' ? phaseMissingCondition(change, parsed.phaseName) : false;
-            case 'CHANGE_ORDER_MIGRATION_REQUIRED': {
-                if (!parsed)
-                    return false;
-                if (parsed.kind === 'phase')
-                    return orderMigrationRequiredPhaseCondition(change, parsed.phaseName);
-                if (parsed.kind === 'batch')
-                    return orderMigrationRequiredBatchCondition(change, parsed.batchPhaseName, parsed.batchKey);
-                if (parsed.kind === 'requirement')
-                    return orderMigrationRequiredRequirementCondition(change, parsed.requirementId, tdd);
-                return false;
-            }
-            case 'CHANGE_TESTS_UNCHANGED': {
-                if (parsed?.kind !== 'batchKey')
-                    return false;
-                const batch = batchForKey(effectiveBatches(change), parsed.batchKey);
-                return !!batch && testsUnchangedCondition(change, batch);
-            }
-            case 'CHANGE_IMPLEMENTATION_UNCHANGED': {
-                if (parsed?.kind !== 'batchKey')
-                    return false;
-                const batch = batchForKey(effectiveBatches(change), parsed.batchKey);
-                return !!batch && implementationUnchangedCondition(batch);
-            }
-            case 'CHANGE_TEST_CHANGED_AFTER_RED': {
-                if (parsed?.kind !== 'batchKey')
-                    return false;
-                const batch = batchForKey(effectiveBatches(change), parsed.batchKey);
-                return !!batch && testChangedAfterRedCondition(batch);
-            }
-            case 'CHANGE_RELEVANT_IMPLEMENTATION_UNCHANGED': {
-                if (parsed?.kind !== 'batchKey' || requirementId === undefined)
-                    return false;
-                const batch = batchForKey(effectiveBatches(change), parsed.batchKey);
-                return !!batch && relevantImplementationUnchangedCondition(batch, requirementId);
-            }
-            default: return false;
+    const scope = {
+        changeId,
+        code: waivableCode,
+        ...(requirementId !== undefined ? { requirementId } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+    };
+    const condition = await evaluateWaiverCondition(root, evidence, tdd, order, scope);
+    if (condition === 'indeterminate') {
+        const change = evidence?.changes.find((entry) => entry.changeId === changeId);
+        if (requirementId !== undefined && change && !change.requirementIds.includes(requirementId)) {
+            throw new Error(`The ${waivableCode} scope cannot be evaluated because ${requirementId} is not declared by ${changeId}.`);
         }
-    })();
-    if (!currentlyReported) {
-        throw new Error(`No matching ${waivableCode} diagnostic is currently reported for ${changeId}${requirementId ? `:${requirementId}` : ''}${detail ? `:${detail}` : ''}.`);
+        throw new Error(`The ${waivableCode} scope for ${changeId}${requirementId ? `:${requirementId}` : ''}${detail ? `:${detail}` : ''} cannot be evaluated.`);
     }
-    for (let index = 0; index < existing.waivers.length; index++) {
-        const record = existing.waivers[index];
-        if (scopeMatches(record, changeId, waivableCode, requirementId, detail)
-            && (await waiverLinkage(root, evidence, order, existing.waivers, index)).valid) {
-            const hash = digest(canonicalJson(await snapshotPayload(root, evidence, tdd, order, changeId, waivableCode, requirementId, detail)));
-            if (record.snapshotVersion === CURRENT_SNAPSHOT_VERSION && record.snapshotHash === hash) {
-                throw new Error(`${changeId}:${waivableCode}${requirementId ? `:${requirementId}` : ''}${detail ? `:${detail}` : ''} already has an active waiver.`);
-            }
-        }
+    if (condition === 'false') {
+        throw new Error(`No matching ${waivableCode} diagnostic is currently reported for ${changeId}${requirementId ? `:${requirementId}` : ''}${detail ? `:${detail}` : ''}; the evaluated condition is false.`);
+    }
+    const waiverContext = await buildWaiverContext(root, evidence, tdd, {
+        loaded: existing,
+        order,
+    });
+    const authoritative = authoritativeWaiverIndex(waiverContext, scope);
+    if (authoritative !== -1 && !isWaiverStale(waiverContext, authoritative)) {
+        throw new Error(`${changeId}:${waivableCode}${requirementId ? `:${requirementId}` : ''}${detail ? `:${detail}` : ''} already has an active waiver.`);
     }
     const snapshotHash = digest(canonicalJson(await snapshotPayload(root, evidence, tdd, order, changeId, waivableCode, requirementId, detail)));
     const orderRecord = await appendEvidenceOrder(root, {
@@ -639,13 +898,11 @@ export async function recordChangeWaiver(root, changeId, code, requirementId, de
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-006 REQ-CHANGE-EVIDENCE-WAIVER-012 REQ-CHANGE-EVIDENCE-WAIVER-016
  * @design DES-CHANGE-EVIDENCE-WAIVER-005
  */
-export async function activeWaivers(root) {
-    const loaded = await loadChangeWaiverEvidence(root);
+export async function activeWaivers(root, precomputed) {
+    const waiverContext = precomputed ?? await buildWaiverContext(root, await loadChangeEvidence(root), await loadTddEvidence(root));
+    const loaded = waiverContext.loaded;
     if (!loaded || loaded.malformed)
         return [];
-    const evidence = await loadChangeEvidence(root);
-    const tdd = await loadTddEvidence(root);
-    const waiverContext = await buildWaiverContext(root, evidence, tdd);
     const results = [];
     const groupsSeen = new Set();
     for (let index = 0; index < loaded.waivers.length; index++) {
@@ -656,11 +913,16 @@ export async function activeWaivers(root) {
         if (groupsSeen.has(scopeKey))
             continue;
         groupsSeen.add(scopeKey);
-        const authoritative = authoritativeIndex(waiverContext, record.changeId, record.code, record.requirementId, record.detail);
+        const authoritative = authoritativeWaiverIndex(waiverContext, {
+            changeId: record.changeId,
+            code: record.code,
+            ...(record.requirementId !== undefined ? { requirementId: record.requirementId } : {}),
+            ...(record.detail !== undefined ? { detail: record.detail } : {}),
+        });
         if (authoritative === -1)
             continue;
         const authoritativeRecord = loaded.waivers[authoritative];
-        if (!nonStale(authoritativeRecord, authoritative, waiverContext))
+        if (isWaiverStale(waiverContext, authoritative))
             continue;
         results.push({
             changeId: authoritativeRecord.changeId,
@@ -674,15 +936,82 @@ export async function activeWaivers(root) {
     }
     return results;
 }
+export async function evaluateChangeWaiverState(root, evidence, tdd, order, waivers) {
+    const linkage = [];
+    const currentHash = [];
+    for (let index = 0; index < waivers.waivers.length; index++) {
+        const recordLinkage = waiverLinkage(order, waivers.waivers, index);
+        linkage.push(recordLinkage);
+        if (recordLinkage.valid) {
+            const record = waivers.waivers[index];
+            currentHash.push(digest(canonicalJson(await snapshotPayload(root, evidence, tdd, order, record.changeId, record.code, record.requirementId, record.detail))));
+        }
+        else {
+            currentHash.push(undefined);
+        }
+    }
+    const condition = [];
+    for (let index = 0; index < waivers.waivers.length; index++) {
+        const record = waivers.waivers[index];
+        condition.push(linkage[index]?.valid
+            ? await evaluateWaiverCondition(root, evidence, tdd, order, {
+                changeId: record.changeId,
+                code: record.code,
+                ...(record.requirementId !== undefined ? { requirementId: record.requirementId } : {}),
+                ...(record.detail !== undefined ? { detail: record.detail } : {}),
+            })
+            : undefined);
+    }
+    const context = {
+        loaded: { schemaVersion: 1, waivers: waivers.waivers, malformed: false },
+        order,
+        linkage,
+        currentHash,
+        condition,
+    };
+    const authoritative = new Map();
+    const stale = [];
+    for (const record of waivers.waivers) {
+        const scope = JSON.stringify([record.changeId, record.code, record.requirementId, record.detail]);
+        if (authoritative.has(scope))
+            continue;
+        const index = authoritativeWaiverIndex(context, {
+            changeId: record.changeId,
+            code: record.code,
+            ...(record.requirementId !== undefined ? { requirementId: record.requirementId } : {}),
+            ...(record.detail !== undefined ? { detail: record.detail } : {}),
+        });
+        if (index === -1)
+            continue;
+        const selected = waivers.waivers[index];
+        if (isWaiverStale(context, index)) {
+            stale.push({
+                changeId: selected.changeId,
+                code: selected.code,
+                ...(selected.requirementId !== undefined ? { requirementId: selected.requirementId } : {}),
+                ...(selected.detail !== undefined ? { detail: selected.detail } : {}),
+            });
+        }
+        authoritative.set(scope, JSON.stringify([
+            selected.changeId,
+            selected.code,
+            selected.requirementId,
+            selected.detail,
+            selected.approver,
+            selected.reason,
+            selected.recordedAt,
+            selected.snapshotVersion,
+            selected.snapshotHash,
+        ]));
+    }
+    return { stale, authoritative };
+}
 /** @id CODE-CHANGE-EVIDENCE-WAIVER-012
  * @implements REQ-CHANGE-EVIDENCE-WAIVER-007 REQ-CHANGE-EVIDENCE-WAIVER-011
  * @design DES-CHANGE-EVIDENCE-WAIVER-005
  */
-export async function waiverEvidenceDiagnostics(root) {
-    const loaded = await loadChangeWaiverEvidence(root);
-    const evidence = await loadChangeEvidence(root);
-    const tdd = await loadTddEvidence(root);
-    const waiverContext = await buildWaiverContext(root, evidence, tdd);
-    return reportWaiverEvidenceDiagnostics({ ...waiverContext, loaded }, evidence, tdd);
+export async function waiverEvidenceDiagnostics(root, precomputed) {
+    const waiverContext = precomputed ?? await buildWaiverContext(root, await loadChangeEvidence(root), await loadTddEvidence(root));
+    return reportWaiverEvidenceDiagnostics(waiverContext);
 }
 //# sourceMappingURL=change-waiver.js.map