musubix3 0.1.20 → 0.1.21

package/dist/packages/analysis/src/evidence-merge.js

@@ -1,9 +1,9 @@
-import { link, mkdir, open, readFile, realpath, rename, rm, unlink, writeFile } from 'node:fs/promises';
+import { link, mkdir, open, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
 import { canonicalJson, evaluateChangeWaiverState, loadChangeWaiverEvidence, } from './change-waiver.js';
-import { assertEvidenceMergeReady, assertEvidenceMergeStartable, } from './evidence-merge-guard.js';
-import { assertCoordinatedEvidenceRead, withEvidenceWriterLock, } from './evidence-writer-lock.js';
-import { batchKey, effectiveBatches, loadChangeEvidence, } from './change-evidence.js';
+import { assertEvidenceMergeReady, assertEvidenceMergeStartable, evidenceJournals, } from './evidence-merge-guard.js';
+import { assertCoordinatedEvidenceRead, resolveEvidenceWriterCoordinatedRoot, withEvidenceWriterLock, } from './evidence-writer-lock.js';
+import { batchKey, effectiveBatches, loadChangeEvidence, qualityIdentity, qualityLineage, qualityPayloadForIdentity, } from './change-evidence.js';
 import { digest, exists, readText, safePath, within } from './files.js';
 import { loadEvidenceOrder, validateEvidenceOrderLog, } from './order.js';
 import { loadTddEvidence, } from './tdd.js';
@@ -15,7 +15,7 @@ const WAIVERS_PATH = `${EVIDENCE_DIR}/change-waivers.json`;
 const JOURNAL_PATH = `${EVIDENCE_DIR}/.merge-transaction.json`;
 const STAGING_PREFIX = `${EVIDENCE_DIR}/.merge-transaction.`;
 const TARGETS = [ORDER_PATH, TDD_PATH, CHANGES_PATH, WAIVERS_PATH];
-const TDD_PHASES = ['red', 'green', 'refactor', 'migrate', 'void'];
+const TDD_PHASES = ['red', 'green', 'refactor', 'migrate', 'void', 'archive'];
 const CHANGE_PHASES = ['impact', 'requirements', 'design', 'red', 'implementation', 'green', 'quality'];
 const BATCH_PHASES = ['red', 'implementation', 'green'];
 function json(value) {
@@ -46,6 +46,8 @@ function nonWaiverOrderKey(record) {
         record.kind,
         record.entityId,
         record.phase,
+        record.oldTestId ?? null,
+        record.newTestId ?? null,
         record.code ?? null,
         record.requirementId ?? null,
         record.detail ?? null,
@@ -76,7 +78,12 @@ function batchPhase(record, change) {
 function payloadFor(history, record) {
     if (record.kind === 'tdd') {
         const cycle = history.tdd.cycles.find((entry) => entry.cycleId === record.entityId);
-        const value = cycle?.[record.phase];
+        const value = record.phase === 'migrate'
+            ? (cycle?.migrateHistory?.find((entry) => entry.order === record.sequence
+                || ((entry.oldTestId ?? null) === (record.oldTestId ?? null)
+                    && (entry.newTestId ?? null) === (record.newTestId ?? null)))
+                ?? (cycle?.migrate?.order === record.sequence ? cycle.migrate : undefined))
+            : cycle?.[record.phase];
         return value ? { kind: 'tdd', identity: `${record.entityId}:${record.phase}`, value } : undefined;
     }
     if (record.phase === 'waiver') {
@@ -86,6 +93,10 @@ function payloadFor(history, record) {
     const change = history.changes.changes.find((entry) => entry.changeId === record.entityId);
     if (!change)
         return undefined;
+    if (/^quality(?::[1-9]\d*)?$/.test(record.phase)) {
+        const value = qualityPayloadForIdentity(change, record.phase);
+        return value ? { kind: 'change', identity: `${record.entityId}:${record.phase}`, value } : undefined;
+    }
     const value = batchPhase(record, change);
     return value ? { kind: 'change', identity: `${record.entityId}:${record.phase}`, value } : undefined;
 }
@@ -165,15 +176,18 @@ function validateInputEntities(history) {
     }
     const phaseSet = new Set();
     for (const record of history.tdd.chain ?? []) {
-        const key = `${record.cycleId}:${record.phase}`;
+        const key = canonicalJson(record.phase === 'migrate'
+            ? [record.cycleId, record.phase, record.oldTestId ?? null, record.newTestId ?? null]
+            : [record.cycleId, record.phase]);
         if (phaseSet.has(key))
             diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Duplicate TDD chain identity.', TDD_PATH, key));
         phaseSet.add(key);
     }
     for (const cycle of history.tdd.cycles) {
-        for (const phase of TDD_PHASES) {
+        for (const phase of TDD_PHASES.filter((entry) => entry !== 'migrate')) {
             const value = cycle[phase];
-            if (value && !phaseSet.has(`${cycle.cycleId}:${phase}`)) {
+            const phaseIdentity = canonicalJson([cycle.cycleId, phase]);
+            if (value && !phaseSet.has(phaseIdentity)) {
                 diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Missing TDD chain identity.', TDD_PATH, `${cycle.cycleId}:${phase}`));
             }
             if (value && !Number.isInteger(value.order)) {
@@ -187,16 +201,75 @@ function validateInputEntities(history) {
                 }
             }
         }
+        const migrations = cycle.migrateHistory?.length ? cycle.migrateHistory : (cycle.migrate ? [cycle.migrate] : []);
+        for (const migration of migrations) {
+            const identity = canonicalJson([cycle.cycleId, 'migrate', migration.oldTestId ?? null, migration.newTestId ?? null]);
+            if (!phaseSet.has(identity)) {
+                diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Missing TDD chain identity.', TDD_PATH, `${cycle.cycleId}:migrate`));
+            }
+            if (!Number.isInteger(migration.order)) {
+                diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'TDD phase lacks monotonic order evidence; migrate or regenerate it before merging.', TDD_PATH, `${cycle.cycleId}:migrate`));
+            }
+            if (migration.order !== undefined) {
+                const matches = history.order.records.filter((record) => record.sequence === migration.order && record.kind === 'tdd'
+                    && record.entityId === cycle.cycleId && record.phase === 'migrate'
+                    && (record.oldTestId ?? null) === (migration.oldTestId ?? null)
+                    && (record.newTestId ?? null) === (migration.newTestId ?? null));
+                if (matches.length !== 1) {
+                    diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'TDD phase does not pair to exactly one order record.', TDD_PATH, `${cycle.cycleId}:migrate`));
+                }
+            }
+        }
     }
     for (const key of phaseSet) {
-        const [cycleId, phase] = key.split(':', 2);
+        const parsed = JSON.parse(key);
+        const [cycleId, phase, oldTestId, newTestId] = parsed;
         const cycle = history.tdd.cycles.find((entry) => entry.cycleId === cycleId);
-        if (!cycle?.[phase]) {
+        const present = phase === 'migrate'
+            ? (cycle?.migrateHistory?.some((entry) => (entry.oldTestId ?? null) === (oldTestId ?? null) && (entry.newTestId ?? null) === (newTestId ?? null))
+                || (cycle?.migrate && (cycle.migrate.oldTestId ?? null) === (oldTestId ?? null) && (cycle.migrate.newTestId ?? null) === (newTestId ?? null)))
+            : !!cycle?.[phase];
+        if (!present) {
             diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Extra TDD chain identity.', TDD_PATH, key));
         }
     }
     for (const change of history.changes.changes) {
-        for (const phase of CHANGE_PHASES) {
+        if (history.changes.schemaVersion === 1 && change.qualityHistory !== undefined) {
+            diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Schema version 1 cannot contain Quality history.', CHANGES_PATH, change.changeId));
+        }
+        const historyShapeValid = change.qualityHistory === undefined
+            || (Array.isArray(change.qualityHistory) && change.qualityHistory.length > 0);
+        if (!historyShapeValid) {
+            diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality history must be a non-empty array when present.', CHANGES_PATH, change.changeId));
+        }
+        if (Array.isArray(change.qualityHistory) && change.qualityHistory.length > 0 && !change.phases.quality) {
+            diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality history requires an authoritative Quality checkpoint.', CHANGES_PATH, change.changeId));
+        }
+        const lineage = Array.isArray(change.qualityHistory)
+            ? [...change.qualityHistory, ...(change.phases.quality ? [change.phases.quality] : [])]
+            : [...(change.phases.quality ? [change.phases.quality] : [])];
+        const qualityIdentities = new Set();
+        let previousQualityOrder = 0;
+        for (const [index, value] of lineage.entries()) {
+            const identity = qualityIdentity(index + 1);
+            qualityIdentities.add(identity);
+            if (value.phase !== 'quality' || typeof value.recordedAt !== 'string'
+                || !value.fingerprints || !Number.isInteger(value.order) || value.order <= previousQualityOrder) {
+                diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality lineage checkpoint is malformed.', CHANGES_PATH, `${change.changeId}:${identity}`));
+                continue;
+            }
+            previousQualityOrder = value.order;
+            const matches = history.order.records.filter((record) => record.sequence === value.order && record.kind === 'change'
+                && record.entityId === change.changeId && record.phase === identity);
+            if (matches.length !== 1) {
+                diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality checkpoint does not pair to exactly one order record.', CHANGES_PATH, `${change.changeId}:${identity}`));
+            }
+        }
+        if (history.order.records.some((record) => record.kind === 'change' && record.entityId === change.changeId
+            && /^quality(?::\d+)?$/.test(record.phase) && !qualityIdentities.has(record.phase))) {
+            diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality order identity is orphaned or malformed.', CHANGES_PATH, change.changeId));
+        }
+        for (const phase of CHANGE_PHASES.filter((entry) => entry !== 'quality')) {
             const value = change.phases[phase];
             if (value && !Number.isInteger(value.order)) {
                 diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Change phase lacks monotonic order evidence; migrate or regenerate it before merging.', CHANGES_PATH, `${change.changeId}:${phase}`));
@@ -262,7 +335,8 @@ async function validateIncomingWorktree(root, base, incoming) {
  * @design DES-EVIDENCE-HISTORY-MERGE-001
  */
 async function planEvidenceMerge(root, incomingRoot) {
-    const [baseReal, incomingReal] = await Promise.all([realpath(root), realpath(incomingRoot)]);
+    const baseReal = resolveEvidenceWriterCoordinatedRoot(root);
+    const incomingReal = resolveEvidenceWriterCoordinatedRoot(incomingRoot);
     const nested = (parent, child) => {
         const rel = relative(parent, child);
         return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
@@ -460,11 +534,16 @@ function mergeChanges(plan, diagnostics) {
     const changes = structuredClone(plan.base.changes.changes);
     const byId = new Map(changes.map((change) => [change.changeId, change]));
     for (const change of changes) {
-        for (const phase of CHANGE_PHASES) {
+        for (const phase of CHANGE_PHASES.filter((entry) => entry !== 'quality')) {
             const item = change.phases[phase];
             if (item)
                 change.phases[phase] = rewriteChangePhase(item, 'base', plan);
         }
+        if (change.qualityHistory) {
+            change.qualityHistory = change.qualityHistory.map((item) => rewriteChangePhase(item, 'base', plan));
+        }
+        if (change.phases.quality)
+            change.phases.quality = rewriteChangePhase(change.phases.quality, 'base', plan);
         for (const batch of change.tddBatches ?? []) {
             for (const phase of BATCH_PHASES) {
                 const item = batch[phase];
@@ -477,11 +556,16 @@ function mergeChanges(plan, diagnostics) {
         const target = byId.get(sourceChange.changeId);
         if (!target) {
             const clone = structuredClone(sourceChange);
-            for (const phase of CHANGE_PHASES) {
+            for (const phase of CHANGE_PHASES.filter((entry) => entry !== 'quality')) {
                 const item = clone.phases[phase];
                 if (item)
                     clone.phases[phase] = rewriteChangePhase(item, 'incoming', plan);
             }
+            if (clone.qualityHistory) {
+                clone.qualityHistory = clone.qualityHistory.map((item) => rewriteChangePhase(item, 'incoming', plan));
+            }
+            if (clone.phases.quality)
+                clone.phases.quality = rewriteChangePhase(clone.phases.quality, 'incoming', plan);
             for (const batch of clone.tddBatches ?? []) {
                 for (const phase of BATCH_PHASES) {
                     const item = batch[phase];
@@ -497,7 +581,7 @@ function mergeChanges(plan, diagnostics) {
             diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Matching change ID has different requirement IDs.', CHANGES_PATH, sourceChange.changeId));
             continue;
         }
-        for (const phase of CHANGE_PHASES) {
+        for (const phase of CHANGE_PHASES.filter((entry) => entry !== 'quality')) {
             const left = target.phases[phase];
             const right = sourceChange.phases[phase];
             if (left && right && !semanticEqual(left, right)) {
@@ -506,6 +590,21 @@ function mergeChanges(plan, diagnostics) {
             else if (!left && right)
                 target.phases[phase] = rewriteChangePhase(right, 'incoming', plan);
         }
+        const leftLineage = qualityLineage(target);
+        const rightLineage = qualityLineage(sourceChange);
+        const shared = Math.min(leftLineage.length, rightLineage.length);
+        const prefix = Array.from({ length: shared }, (_, index) => semanticEqual(leftLineage[index], rightLineage[index])).every(Boolean);
+        if (!prefix) {
+            diagnostics.push(mergeDiagnostic('EVIDENCE_MERGE_CONFLICT', 'Quality lineages diverge at the same ordinal.', CHANGES_PATH, sourceChange.changeId));
+        }
+        else if (rightLineage.length > leftLineage.length) {
+            const rewritten = rightLineage.map((item) => rewriteChangePhase(item, 'incoming', plan));
+            target.phases.quality = rewritten.at(-1);
+            if (rewritten.length > 1)
+                target.qualityHistory = rewritten.slice(0, -1);
+            else
+                delete target.qualityHistory;
+        }
         for (const incomingBatch of sourceChange.tddBatches ?? []) {
             const targetBatches = target.tddBatches ??= [];
             const key = batchKey(incomingBatch.requirementIds);
@@ -527,7 +626,12 @@ function mergeChanges(plan, diagnostics) {
             }
         }
     }
-    return { ...plan.base.changes, schemaVersion: 1, changes };
+    const hasHistory = changes.some((change) => (change.qualityHistory?.length ?? 0) > 0);
+    return {
+        ...plan.base.changes,
+        schemaVersion: hasHistory || plan.base.changes.schemaVersion === 2 || plan.incoming.changes.schemaVersion === 2 ? 2 : 1,
+        changes,
+    };
 }
 function mergeWaivers(plan) {
     const waivers = structuredClone(plan.base.waivers.waivers).map((record) => rewritePhase(record, 'base', plan));
@@ -606,16 +710,19 @@ function validateCandidateReferences(order, tdd, changes, waivers) {
             diagnostics.push(mergeDiagnostic('TDD_ORDER_SEQUENCE', 'Refactor is not after Green in monotonic evidence order.', TDD_PATH, `${cycle.cycleId}:refactor`));
         }
         const latestNonMigrateOrder = cycle.refactor?.valid ? cycle.refactor.order : cycle.green?.order;
-        if (cycle.migrate?.order !== undefined && latestNonMigrateOrder !== undefined
-            && cycle.migrate.order <= latestNonMigrateOrder) {
-            diagnostics.push(mergeDiagnostic('TDD_ORDER_SEQUENCE', 'Migrate is not after Green/Refactor in monotonic evidence order.', TDD_PATH, `${cycle.cycleId}:migrate`));
+        const migrations = cycle.migrateHistory?.length ? cycle.migrateHistory : (cycle.migrate ? [cycle.migrate] : []);
+        for (const migration of migrations) {
+            if (migration.order !== undefined && latestNonMigrateOrder !== undefined
+                && migration.order <= latestNonMigrateOrder) {
+                diagnostics.push(mergeDiagnostic('TDD_ORDER_SEQUENCE', 'Migrate is not after Green/Refactor in monotonic evidence order.', TDD_PATH, `${cycle.cycleId}:migrate`));
+            }
         }
     }
     for (const identity of chainKeys) {
         diagnostics.push(mergeDiagnostic('TDD_CHAIN_ORPHAN', 'Rebuilt TDD chain entry has no phase payload.', TDD_PATH, identity));
     }
     for (const change of changes.changes) {
-        for (const phase of CHANGE_PHASES) {
+        for (const phase of CHANGE_PHASES.filter((entry) => entry !== 'quality')) {
             const value = change.phases[phase];
             if (!value)
                 continue;
@@ -624,6 +731,22 @@ function validateCandidateReferences(order, tdd, changes, waivers) {
                 diagnostics.push(mergeDiagnostic('CHANGE_ORDER_MISMATCH', 'Rebuilt change phase does not match its order record.', CHANGES_PATH, `${change.changeId}:${phase}`));
             }
         }
+        const qualityIdentities = new Set();
+        let previousQualityOrder = 0;
+        for (const [index, value] of qualityLineage(change).entries()) {
+            const identity = qualityIdentity(index + 1);
+            qualityIdentities.add(identity);
+            const record = value.order === undefined ? undefined : orderAt.get(value.order);
+            if (!record || record.kind !== 'change' || record.entityId !== change.changeId
+                || record.phase !== identity || value.order <= previousQualityOrder) {
+                diagnostics.push(mergeDiagnostic('CHANGE_QUALITY_HISTORY_MALFORMED', 'Rebuilt Quality checkpoint does not match its ordinal order record.', CHANGES_PATH, `${change.changeId}:${identity}`));
+            }
+            previousQualityOrder = value.order ?? previousQualityOrder;
+        }
+        if (order.records.some((record) => record.kind === 'change' && record.entityId === change.changeId
+            && /^quality(?::\d+)?$/.test(record.phase) && !qualityIdentities.has(record.phase))) {
+            diagnostics.push(mergeDiagnostic('CHANGE_QUALITY_HISTORY_MALFORMED', 'Rebuilt Quality order record is orphaned.', CHANGES_PATH, change.changeId));
+        }
         const fullSetKey = batchKey(change.requirementIds);
         if (change.phases.requirements?.order !== undefined && change.phases.impact?.order !== undefined
             && change.phases.requirements.order <= change.phases.impact.order) {
@@ -706,8 +829,8 @@ function buildCandidates(plan) {
         },
     };
 }
-async function fsyncPath(path) {
-    const handle = await open(path, 'r');
+async function fsyncFile(path) {
+    const handle = await open(path, 'r+');
     try {
         await handle.sync();
     }
@@ -715,14 +838,19 @@ async function fsyncPath(path) {
         await handle.close();
     }
 }
-async function fsyncDirectory(path) {
+export async function fsyncEvidenceMergeDirectory(path, openDirectory = open) {
+    let handle;
     try {
-        await fsyncPath(path);
+        handle = await openDirectory(path, 'r');
+        await handle.sync();
     }
     catch (cause) {
         if (!['EISDIR', 'EPERM', 'EACCES', 'EINVAL'].includes(cause.code ?? ''))
             throw cause;
     }
+    finally {
+        await handle?.close();
+    }
 }
 async function removeIfPresent(path) {
     await rm(path, { force: true });
@@ -743,7 +871,7 @@ async function restoreJournal(root, journal) {
         if (target.existed) {
             const staging = `${absolute}.${journal.transactionId}.restore`;
             await writeFile(staging, Buffer.from(target.originalBase64, 'base64'));
-            await fsyncPath(staging);
+            await fsyncFile(staging);
             await rename(staging, absolute);
         }
         else {
@@ -751,9 +879,9 @@ async function restoreJournal(root, journal) {
         }
         await removeIfPresent(await safePath(root, target.temporaryPath));
     }
-    await fsyncDirectory(evidenceDirectory);
+    await fsyncEvidenceMergeDirectory(evidenceDirectory);
     await removeIfPresent(await safePath(root, JOURNAL_PATH));
-    await fsyncDirectory(evidenceDirectory);
+    await fsyncEvidenceMergeDirectory(evidenceDirectory);
 }
 /** @id CODE-EVIDENCE-HISTORY-MERGE-003
  * @implements REQ-EVIDENCE-HISTORY-MERGE-004
@@ -784,7 +912,7 @@ async function applyCandidates(root, candidates, faultAt) {
     if (faultAt === 'journal:staging')
         throw new Error('Injected evidence merge failure at journal:staging.');
     await writeFile(stagingJournal, json(journal), { flag: 'wx' });
-    await fsyncPath(stagingJournal);
+    await fsyncFile(stagingJournal);
     if (faultAt === 'journal:publication') {
         throw new Error('EVIDENCE_MERGE_RECOVERY_REQUIRED: injected failure at journal:publication.');
     }
@@ -799,7 +927,7 @@ async function applyCandidates(root, candidates, faultAt) {
         }
         throw cause;
     }
-    await fsyncDirectory(dirname(journalAbsolute));
+    await fsyncEvidenceMergeDirectory(dirname(journalAbsolute));
     try {
         for (let index = 0; index < targets.length; index++) {
             if (faultAt === `temporary:${index}`)
@@ -807,7 +935,7 @@ async function applyCandidates(root, candidates, faultAt) {
             const target = targets[index];
             const temporary = await safePath(root, target.temporaryPath);
             await writeFile(temporary, Buffer.from(target.candidateBase64, 'base64'), { flag: 'wx' });
-            await fsyncPath(temporary);
+            await fsyncFile(temporary);
         }
         for (let index = 0; index < targets.length; index++) {
             if (faultAt === `replace:${index}`)
@@ -815,15 +943,15 @@ async function applyCandidates(root, candidates, faultAt) {
             const target = targets[index];
             await rename(await safePath(root, target.temporaryPath), await safePath(root, target.path));
         }
-        await fsyncDirectory(dirname(journalAbsolute));
+        await fsyncEvidenceMergeDirectory(dirname(journalAbsolute));
         journal.state = 'committed';
         const commitStaging = await safePath(root, `${STAGING_PREFIX}${transactionId}.commit.json`);
         await writeFile(commitStaging, json(journal), { flag: 'wx' });
-        await fsyncPath(commitStaging);
+        await fsyncFile(commitStaging);
         if (faultAt === 'commit-marker')
             throw new Error('Injected evidence merge failure at commit-marker.');
         await rename(commitStaging, journalAbsolute);
-        await fsyncDirectory(dirname(journalAbsolute));
+        await fsyncEvidenceMergeDirectory(dirname(journalAbsolute));
         if (faultAt === 'cleanup')
             throw new Error('EVIDENCE_MERGE_RECOVERY_REQUIRED: injected failure at cleanup.');
         await removeIfPresent(journalAbsolute);
@@ -968,6 +1096,13 @@ export async function recoverEvidenceMerge(root) {
     return withEvidenceWriterLock(root, 'evidence merge --recover', () => recoverEvidenceMergeUnlocked(root));
 }
 async function recoverEvidenceMergeUnlocked(root) {
+    const journals = await evidenceJournals(root);
+    if (journals.merge && journals.qualityRefresh) {
+        throw new Error('EVIDENCE_MERGE_RECOVERY_UNSAFE: merge and Quality-refresh journals coexist.');
+    }
+    if (journals.qualityRefresh) {
+        throw new Error('CHANGE_QUALITY_REFRESH_RECOVERY_REQUIRED: run change quality-recover.');
+    }
     const journalAbsolute = await safePath(root, JOURNAL_PATH);
     const evidenceDir = await safePath(root, EVIDENCE_DIR);
     let staging = [];
@@ -1028,20 +1163,20 @@ async function recoverEvidenceMergeUnlocked(root) {
         if (digest(actual) !== target.candidateSha256) {
             const stagingPath = `${absolute}.${journal.transactionId}.recover`;
             await writeFile(stagingPath, Buffer.from(target.candidateBase64, 'base64'));
-            await fsyncPath(stagingPath);
+            await fsyncFile(stagingPath);
             await rename(stagingPath, absolute);
-            await fsyncDirectory(evidenceDir);
+            await fsyncEvidenceMergeDirectory(evidenceDir);
         }
         const verified = await readFile(absolute, 'utf8');
         if (digest(verified) !== target.candidateSha256) {
             throw unsafeRecovery('Candidate verification failed after rewrite.', inventory);
         }
     }
-    await fsyncDirectory(evidenceDir);
+    await fsyncEvidenceMergeDirectory(evidenceDir);
     await removeIfPresent(journalAbsolute);
     for (const entry of staging)
         await removeIfPresent(resolve(evidenceDir, entry));
-    await fsyncDirectory(evidenceDir);
+    await fsyncEvidenceMergeDirectory(evidenceDir);
     return { recovered: true, action: 'rolled-forward', discardedStaging: staging.length > 0 };
 }
 //# sourceMappingURL=evidence-merge.js.map