@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/core/dist/operations/write-batch.js

@@ -2,14 +2,16 @@ import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
 import { createReadStream, promises as fs } from "node:fs";
-import { copyFileAtomic, copyFileAtomicExclusive, writeTextFileAtomic, } from "../atomic-write.js";
+import { auditRecordSchema } from "@murphai/contracts";
+import { copyFileAtomic, copyFileAtomicExclusive, writeBytesFileAtomicExclusive, writeTextFileAtomic, } from "../atomic-write.js";
 import { VaultError } from "../errors.js";
 import { ensureDirectory, pathExists } from "../fs.js";
 import { VAULT_LAYOUT } from "../constants.js";
 import { isJsonlRelativePath, isRawRelativePath, isVaultFilesystemCaseInsensitive, normalizeRelativeVaultPath, normalizeRelativeVaultPathForComparison, normalizeVaultRoot, resolveVaultPath, resolveVaultPathOnDisk, } from "../path-safety.js";
 import { toIsoTimestamp } from "../time.js";
 import { isErrnoException, isPlainRecord } from "../types.js";
-import { applyImmutableWriteTarget, applyJsonlAppendTarget, applyTextWriteTarget, assertWriteTargetPolicy, assertWriteTargetPolicyForVault, prepareVerifiedDeleteTarget, prepareVerifiedWriteTarget, } from "../write-policy.js";
+import { assertAuthorizedIntegrationIngestAppendPlan, appendArchivedIntegrationIngestShard, buildIntegrationIngestAppendPlan, parseIntegrationIngestAppendPayload, prepareLiveIntegrationIngestAppendPayload, readArchivedIntegrationIngestShardText, truncateArchivedIntegrationIngestShard, } from "../integration-ingests.js";
+import { applyImmutableWriteTarget, applyJsonlAppendTarget, applyTextWriteTarget, assertJsonlAppendTargetCanAppend, isIntegrationIngestJsonlAppendTarget, assertWriteTargetPolicy, assertWriteTargetPolicyForVault, prepareVerifiedDeleteTarget, prepareVerifiedWriteTarget, } from "../write-policy.js";
 import { acquireCanonicalWriteLock } from "./canonical-write-lock.js";
 export const WRITE_OPERATION_SCHEMA_VERSION = "murph.write-operation.v1";
 export const WRITE_OPERATION_DIRECTORY = ".runtime/operations";
@@ -146,6 +148,9 @@ function resolveHostedCanonicalWriteReceiptDirectoryFromEnv(env = process.env) {
 function resolveAmbientHostedCanonicalWritePort() {
     return hostedCanonicalWritePortStorage.getStore() ?? null;
 }
+export function readHostedCanonicalWritePort() {
+    return resolveAmbientHostedCanonicalWritePort();
+}
 export async function withHostedCanonicalWritePort(port, run) {
     return await hostedCanonicalWritePortStorage.run(port, run);
 }
@@ -178,6 +183,7 @@ export async function applyHostedCanonicalWriteReceipt(input) {
                     ref: action.contentRef,
                 });
                 await applyHostedCanonicalJsonlAppendReceiptAction({
+                    allowArchivedIntegrationIngestAmendment: action.allowArchivedIntegrationIngestAmendment === true,
                     baseByteLength: action.baseByteLength,
                     baseSha256: action.baseSha256,
                     bytes,
@@ -203,6 +209,18 @@ export async function applyHostedCanonicalWriteReceipt(input) {
             }
             case "delete":
                 await applyHostedCanonicalDeleteReceiptAction({
+                    allowRaw: action.allowRaw === true,
+                    targetRelativePath: action.targetRelativePath,
+                    vaultRoot,
+                });
+                break;
+            case "delete_if_match":
+                await applyHostedCanonicalDeleteReceiptAction({
+                    allowRaw: action.allowRaw === true,
+                    expectedTargetReceipt: {
+                        byteLength: action.expectedByteLength,
+                        sha256: action.expectedSha256,
+                    },
                     targetRelativePath: action.targetRelativePath,
                     vaultRoot,
                 });
@@ -248,6 +266,33 @@ async function applyHostedCanonicalJsonlAppendReceiptAction(input) {
     const target = await prepareVerifiedWriteTarget(input.vaultRoot, input.targetRelativePath, {
         kind: "jsonl_append",
     });
+    const comparisonOptions = {
+        caseInsensitive: await isVaultFilesystemCaseInsensitive(input.vaultRoot),
+    };
+    try {
+        await assertJsonlAppendTargetCanAppend(target, comparisonOptions);
+    }
+    catch (error) {
+        if (isArchivedIntegrationIngestAppendError(error, target, comparisonOptions)) {
+            if (input.allowArchivedIntegrationIngestAmendment) {
+                await appendArchivedIntegrationIngestShard({
+                    expectedBaseByteLength: input.baseByteLength,
+                    expectedBaseSha256: input.baseSha256,
+                    payload: Buffer.from(input.bytes).toString("utf8"),
+                    targetRelativePath: target.relativePath,
+                    vaultRoot: input.vaultRoot,
+                });
+                return;
+            }
+            await assertArchivedIntegrationIngestHostedAppendAlreadyApplied({
+                bytes: input.bytes,
+                targetRelativePath: target.relativePath,
+                vaultRoot: input.vaultRoot,
+            });
+            return;
+        }
+        throw error;
+    }
     const originalSize = input.originalSize ?? 0;
     if (input.baseByteLength !== originalSize) {
         throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical JSONL append base receipt does not match the recorded base size.");
@@ -261,22 +306,110 @@ async function applyHostedCanonicalJsonlAppendReceiptAction(input) {
             throw error;
         }
     }
-    if (existing.byteLength < originalSize) {
-        throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical JSONL append base size is not present.");
-    }
-    const baseReceipt = createCommittedPayloadReceipt(existing.subarray(0, input.baseByteLength));
-    if (baseReceipt.sha256 !== input.baseSha256 || baseReceipt.byteLength !== input.baseByteLength) {
-        throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical JSONL append base content does not match the receipt.");
+    const baseSizeIsPresent = existing.byteLength >= originalSize;
+    const baseReceipt = baseSizeIsPresent
+        ? createCommittedPayloadReceipt(existing.subarray(0, input.baseByteLength))
+        : null;
+    const baseMatches = baseReceipt?.sha256 === input.baseSha256
+        && baseReceipt.byteLength === input.baseByteLength;
+    if (baseMatches) {
+        const appendedEnd = originalSize + input.bytes.byteLength;
+        if (existing.byteLength >= appendedEnd &&
+            Buffer.from(existing.subarray(originalSize, appendedEnd)).equals(Buffer.from(input.bytes))) {
+            return;
+        }
+        if (existing.byteLength === originalSize) {
+            await fs.appendFile(target.absolutePath, input.bytes);
+            return;
+        }
     }
-    const appendedEnd = originalSize + input.bytes.byteLength;
-    if (existing.byteLength >= appendedEnd &&
-        Buffer.from(existing.subarray(originalSize, appendedEnd)).equals(Buffer.from(input.bytes))) {
+    if (await tryReconcileHostedCanonicalAuditAppend({
+        bytes: input.bytes,
+        comparisonOptions,
+        existing,
+        target,
+    })) {
         return;
     }
-    if (existing.byteLength !== originalSize) {
-        throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical JSONL append base content does not match the receipt.");
+    throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", baseSizeIsPresent
+        ? "Hosted canonical JSONL append base content does not match the receipt."
+        : "Hosted canonical JSONL append base size is not present.");
+}
+async function tryReconcileHostedCanonicalAuditAppend(input) {
+    const comparisonRelativePath = normalizeRelativeVaultPathForComparison(input.target.relativePath, input.comparisonOptions);
+    const auditDirectory = normalizeRelativeVaultPathForComparison(VAULT_LAYOUT.auditDirectory, input.comparisonOptions);
+    if (!comparisonRelativePath.startsWith(`${auditDirectory}/`) ||
+        !isJsonlRelativePath(input.target.relativePath, input.comparisonOptions)) {
+        return false;
+    }
+    const payload = Buffer.from(input.bytes).toString("utf8");
+    if (!payload.endsWith("\n")) {
+        return false;
+    }
+    const payloadLines = payload.slice(0, -1).split("\n");
+    if (payloadLines.length !== 1 || payloadLines[0]?.length === 0) {
+        return false;
     }
-    await fs.appendFile(target.absolutePath, input.bytes);
+    const incomingRecord = parseHostedAuditRecordLine(payloadLines[0]);
+    if (!incomingRecord) {
+        return false;
+    }
+    const existingText = Buffer.from(input.existing).toString("utf8");
+    if (existingText.length > 0 && !existingText.endsWith("\n")) {
+        return false;
+    }
+    const existingLines = existingText.length === 0 ? [] : existingText.slice(0, -1).split("\n");
+    const existingRecordIds = new Set();
+    let matchingRecord = null;
+    for (const line of existingLines) {
+        if (line.length === 0) {
+            return false;
+        }
+        const record = parseHostedAuditRecordLine(line);
+        if (!record) {
+            return false;
+        }
+        if (existingRecordIds.has(record.id)) {
+            throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical audit replay found a duplicate existing audit record ID.");
+        }
+        existingRecordIds.add(record.id);
+        if (record.id === incomingRecord.id) {
+            matchingRecord = record;
+        }
+    }
+    if (matchingRecord) {
+        if (JSON.stringify(matchingRecord) !== JSON.stringify(incomingRecord)) {
+            throw new VaultError("HOSTED_CANONICAL_WRITE_APPEND_BASE_MISMATCH", "Hosted canonical audit replay found conflicting content for an existing audit record ID.");
+        }
+        return true;
+    }
+    await fs.appendFile(input.target.absolutePath, input.bytes);
+    return true;
+}
+function parseHostedAuditRecordLine(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const result = auditRecordSchema.safeParse(value);
+    return result.success ? result.data : null;
+}
+function isArchivedIntegrationIngestAppendError(error, target, options = {}) {
+    return error instanceof VaultError
+        && error.code === "INTEGRATION_INGEST_SHARD_ARCHIVED"
+        && isIntegrationIngestJsonlAppendTarget(target.relativePath, options);
+}
+async function assertArchivedIntegrationIngestHostedAppendAlreadyApplied(input) {
+    const payload = Buffer.from(input.bytes).toString("utf8");
+    const records = await parseIntegrationIngestAppendPayload(payload, input.targetRelativePath);
+    const plan = await buildIntegrationIngestAppendPlan(input.vaultRoot, records);
+    if (plan.payloads.size === 0) {
+        return;
+    }
+    throw new VaultError("INTEGRATION_INGEST_SHARD_ARCHIVED", `Integration ingest shard "${input.targetRelativePath}" is archived and cannot be appended.`, { relativePath: input.targetRelativePath });
 }
 async function applyHostedCanonicalRawReceiptAction(input) {
     const target = await prepareVerifiedWriteTarget(input.vaultRoot, input.targetRelativePath, {
@@ -293,8 +426,24 @@ async function applyHostedCanonicalRawReceiptAction(input) {
 async function applyHostedCanonicalDeleteReceiptAction(input) {
     const target = await prepareVerifiedDeleteTarget(input.vaultRoot, input.targetRelativePath, {
         allowAppendOnlyJsonl: true,
+        allowRaw: input.allowRaw,
         kind: "delete",
     });
+    if (input.expectedTargetReceipt) {
+        let actualReceipt;
+        try {
+            actualReceipt = await createFileContentReceipt(target.absolutePath);
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        if (!receiptsMatch(actualReceipt, input.expectedTargetReceipt)) {
+            throw new VaultError("HOSTED_CANONICAL_WRITE_DELETE_CONFLICT", "Hosted canonical guarded delete found conflicting existing bytes.", { relativePath: input.targetRelativePath });
+        }
+    }
     await fs.rm(target.absolutePath, { force: true });
 }
 async function targetMatchesBytes(absolutePath, bytes) {
@@ -395,10 +544,58 @@ async function safeUnlink(absolutePath) {
         throw error;
     }
 }
+async function removeTreeInterruptibly(absolutePath, signal) {
+    signal?.throwIfAborted();
+    let stats;
+    try {
+        stats = await fs.lstat(absolutePath);
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    signal?.throwIfAborted();
+    if (!stats.isDirectory()) {
+        await safeUnlink(absolutePath);
+        signal?.throwIfAborted();
+        return;
+    }
+    let childNames;
+    try {
+        childNames = await fs.readdir(absolutePath);
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    signal?.throwIfAborted();
+    childNames.sort((left, right) => left.localeCompare(right));
+    for (const childName of childNames) {
+        signal?.throwIfAborted();
+        await removeTreeInterruptibly(path.join(absolutePath, childName), signal);
+    }
+    try {
+        await fs.rmdir(absolutePath);
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    signal?.throwIfAborted();
+}
 export function isTerminalWriteOperationStatus(status) {
     return status === "committed" || status === "rolled_back";
 }
-export async function listWriteOperationMetadataPaths(vaultRoot) {
+async function readWriteOperationDirectoryEntries(vaultRoot) {
     const operationDirectory = await resolveVaultPathOnDisk(vaultRoot, WRITE_OPERATION_DIRECTORY);
     if (!(await pathExists(operationDirectory.absolutePath))) {
         return [];
@@ -407,13 +604,26 @@ export async function listWriteOperationMetadataPaths(vaultRoot) {
     if (!stats.isDirectory()) {
         return [];
     }
-    const entries = await fs.readdir(operationDirectory.absolutePath, { withFileTypes: true });
-    return entries
+    return await fs.readdir(operationDirectory.absolutePath, { withFileTypes: true });
+}
+export async function listWriteOperationMetadataPaths(vaultRoot) {
+    return (await readWriteOperationDirectoryEntries(vaultRoot))
         .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
         .map((entry) => path.posix.join(WRITE_OPERATION_DIRECTORY, entry.name))
         .sort((left, right) => left.localeCompare(right));
 }
+export async function listWriteOperationMetadataPathsWithStageDirectories(vaultRoot) {
+    const entries = await readWriteOperationDirectoryEntries(vaultRoot);
+    const stageDirectoryNames = new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+    return entries
+        .filter((entry) => entry.isFile() &&
+        entry.name.endsWith(".json") &&
+        stageDirectoryNames.has(entry.name.slice(0, -".json".length)))
+        .map((entry) => path.posix.join(WRITE_OPERATION_DIRECTORY, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+}
 export async function pruneTerminalWriteOperationRecords(input) {
+    input.signal?.throwIfAborted();
     const checkpointedAfterMs = parsePruneBoundaryMs(input.checkpointedAfter);
     const nowMs = parsePruneBoundaryMs(input.now ?? new Date());
     const retainedOperationCount = normalizeTerminalWriteOperationRetainedCount(input.retainedOperationCount);
@@ -423,6 +633,7 @@ export async function pruneTerminalWriteOperationRecords(input) {
         prunedByteCount: 0,
         prunedCount: 0,
         prunedFileCount: 0,
+        prunedStageDirectoryCount: 0,
         retainedErroredTerminalCount: 0,
         retainedNewestTerminalCount: 0,
         retainedProtectedCount: 0,
@@ -436,7 +647,10 @@ export async function pruneTerminalWriteOperationRecords(input) {
     }
     const candidates = [];
     const cutoffMs = nowMs - retentionMs;
-    for (const relativePath of await listWriteOperationMetadataPaths(input.vaultRoot)) {
+    const metadataPaths = await listWriteOperationMetadataPaths(input.vaultRoot);
+    input.signal?.throwIfAborted();
+    for (const relativePath of metadataPaths) {
+        input.signal?.throwIfAborted();
         result.scannedCount += 1;
         const operationId = operationIdFromMetadataPath(relativePath);
         if (!operationId) {
@@ -444,6 +658,7 @@ export async function pruneTerminalWriteOperationRecords(input) {
             continue;
         }
         const operation = await readStrictPrunableWriteOperation(input.vaultRoot, relativePath);
+        input.signal?.throwIfAborted();
         if (!operation || operation.operationId !== operationId) {
             result.invalidCount += 1;
             continue;
@@ -461,16 +676,25 @@ export async function pruneTerminalWriteOperationRecords(input) {
             result.invalidCount += 1;
             continue;
         }
+        const stageRoot = (await resolveVaultPathOnDisk(input.vaultRoot, path.posix.join(WRITE_OPERATION_DIRECTORY, operationId))).absolutePath;
+        input.signal?.throwIfAborted();
         if (updatedAtMs >= checkpointedAfterMs) {
+            const stageRootExists = await pathExists(stageRoot);
+            input.signal?.throwIfAborted();
+            if (stageRootExists) {
+                result.retainedStageDirectoryCount += 1;
+            }
             result.retainedUncheckpointedTerminalCount += 1;
             continue;
         }
-        await resolveVaultPathOnDisk(input.vaultRoot, relativePath);
-        const stageRoot = (await resolveVaultPathOnDisk(input.vaultRoot, path.posix.join(WRITE_OPERATION_DIRECTORY, operationId))).absolutePath;
-        if (await pathExists(stageRoot)) {
-            result.retainedStageDirectoryCount += 1;
-            continue;
+        const stageRootExists = await pathExists(stageRoot);
+        input.signal?.throwIfAborted();
+        if (stageRootExists) {
+            await removeTreeInterruptibly(stageRoot, input.signal);
+            result.prunedStageDirectoryCount += 1;
         }
+        await resolveVaultPathOnDisk(input.vaultRoot, relativePath);
+        input.signal?.throwIfAborted();
         candidates.push({
             metadataRelativePath: relativePath,
             operationId,
@@ -481,6 +705,7 @@ export async function pruneTerminalWriteOperationRecords(input) {
     candidates.sort((left, right) => right.updatedAtMs - left.updatedAtMs ||
         left.operationId.localeCompare(right.operationId));
     for (const [index, candidate] of candidates.entries()) {
+        input.signal?.throwIfAborted();
         if (index < retainedOperationCount) {
             result.retainedNewestTerminalCount += 1;
             continue;
@@ -489,13 +714,18 @@ export async function pruneTerminalWriteOperationRecords(input) {
             result.retainedRecentTerminalCount += 1;
             continue;
         }
-        if (await pathExists(candidate.stageRoot)) {
-            result.retainedStageDirectoryCount += 1;
-            continue;
+        const stageRootExists = await pathExists(candidate.stageRoot);
+        input.signal?.throwIfAborted();
+        if (stageRootExists) {
+            await removeTreeInterruptibly(candidate.stageRoot, input.signal);
+            result.prunedStageDirectoryCount += 1;
         }
         const metadataPath = (await resolveVaultPathOnDisk(input.vaultRoot, candidate.metadataRelativePath)).absolutePath;
+        input.signal?.throwIfAborted();
         const measured = await measureExistingFile(metadataPath);
+        input.signal?.throwIfAborted();
         await safeUnlink(metadataPath);
+        input.signal?.throwIfAborted();
         result.prunedCount += 1;
         result.prunedFileCount += measured.fileCount;
         result.prunedByteCount += measured.byteCount;
@@ -575,11 +805,17 @@ function parseStoredAction(value) {
             if (backupRelativePath === null) {
                 return null;
             }
+            const expectedTargetReceipt = parseCommittedPayloadReceipt(record.expectedTargetReceipt);
+            if (expectedTargetReceipt === null) {
+                return null;
+            }
             return {
                 kind: "delete",
                 ...base,
+                allowRaw: record.allowRaw === true,
                 backupRelativePath,
                 effect: record.effect === "delete" ? record.effect : undefined,
+                ...(expectedTargetReceipt ? { expectedTargetReceipt } : {}),
             };
         }
         case "raw_copy": {
@@ -587,11 +823,16 @@ function parseStoredAction(value) {
             if (!stageRelativePath) {
                 return null;
             }
+            const expectedSourceReceipt = parseCommittedPayloadReceipt(record.expectedSourceReceipt);
+            if (expectedSourceReceipt === null) {
+                return null;
+            }
             return {
                 kind: "raw_copy",
                 ...base,
                 allowExistingMatch: record.allowExistingMatch === true,
                 effect: record.effect === "copy" || record.effect === "reuse" ? record.effect : undefined,
+                ...(expectedSourceReceipt ? { expectedSourceReceipt } : {}),
                 mediaType: typeof record.mediaType === "string" ? record.mediaType : "",
                 originalFileName: typeof record.originalFileName === "string" ? record.originalFileName : "",
                 stageRelativePath,
@@ -610,6 +851,10 @@ function parseStoredAction(value) {
             if (committedPayloadReceipt === null) {
                 return null;
             }
+            const expectedTargetReceipt = parseCommittedPayloadReceipt(record.expectedTargetReceipt);
+            if (expectedTargetReceipt === null) {
+                return null;
+            }
             return {
                 kind: "text_write",
                 ...base,
@@ -617,6 +862,7 @@ function parseStoredAction(value) {
                 allowRaw: record.allowRaw === true,
                 backupRelativePath,
                 committedPayloadReceipt,
+                ...(expectedTargetReceipt ? { expectedTargetReceipt } : {}),
                 effect: record.effect === "create" || record.effect === "update" || record.effect === "reuse"
                     ? record.effect
                     : undefined,
@@ -633,6 +879,10 @@ function parseStoredAction(value) {
             if (committedPayloadReceipt === null) {
                 return null;
             }
+            const stagedPayloadReceipt = parseCommittedPayloadReceipt(record.stagedPayloadReceipt);
+            if (stagedPayloadReceipt === null) {
+                return null;
+            }
             const baseContentReceipt = parseCommittedPayloadReceipt(record.baseContentReceipt);
             if (baseContentReceipt === null) {
                 return null;
@@ -640,8 +890,10 @@ function parseStoredAction(value) {
             return {
                 kind: "jsonl_append",
                 ...base,
+                allowArchivedIntegrationIngestAmendment: record.allowArchivedIntegrationIngestAmendment === true,
                 baseContentReceipt,
                 committedPayloadReceipt,
+                stagedPayloadReceipt,
                 effect: record.effect === "append" ? record.effect : undefined,
                 originalSize: typeof record.originalSize === "number" &&
                     Number.isInteger(record.originalSize) &&
@@ -812,6 +1064,36 @@ export async function readStoredWriteOperation(vaultRoot, relativePath) {
     }
     return operation;
 }
+export async function readStoredWriteOperationJsonlAppendPayload(input) {
+    const targetRelativePath = normalizeRelativeVaultPath(input.targetRelativePath);
+    const actions = input.operation.actions.filter((action) => action.kind === "jsonl_append" && action.targetRelativePath === targetRelativePath);
+    if (actions.length !== 1) {
+        return null;
+    }
+    const action = actions[0];
+    if (action.state !== "staged" || !action.stagedPayloadReceipt) {
+        return null;
+    }
+    const expectedStagePrefix = `${stageRootRelativePath(input.operation.operationId)}/payloads/`;
+    if (!action.stageRelativePath.startsWith(expectedStagePrefix)) {
+        return null;
+    }
+    let content;
+    try {
+        const stagePath = await resolveVaultPathOnDisk(input.vaultRoot, action.stageRelativePath);
+        content = await fs.readFile(stagePath.absolutePath, "utf8");
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+    if (!receiptsMatch(createCommittedPayloadReceipt(content), action.stagedPayloadReceipt)) {
+        return null;
+    }
+    return content;
+}
 export async function readRecoverableStoredWriteOperation(vaultRoot, relativePath) {
     try {
         const resolved = resolveVaultPath(vaultRoot, relativePath);
@@ -903,7 +1185,7 @@ export class WriteBatch {
         await batch.persist();
         return batch;
     }
-    async stageRawCopy({ sourcePath, targetRelativePath, allowExistingMatch = false, originalFileName, mediaType, }) {
+    async stageRawCopy({ sourcePath, targetRelativePath, allowExistingMatch = false, expectedSourceReceipt, originalFileName, mediaType, }) {
         this.assertMutable();
         const normalizedTarget = normalizeRelativeVaultPath(targetRelativePath);
         await assertWriteTargetPolicyForVault(this.vaultRoot, normalizedTarget, {
@@ -924,6 +1206,13 @@ export class WriteBatch {
         const stageAbsolutePath = resolveVaultPath(this.vaultRoot, stageRelativePath).absolutePath;
         await ensureDirectory(path.dirname(stageAbsolutePath));
         await fs.copyFile(sourceAbsolutePath, stageAbsolutePath);
+        if (expectedSourceReceipt) {
+            const stagedReceipt = await createFileContentReceipt(stageAbsolutePath);
+            if (!receiptsMatch(stagedReceipt, expectedSourceReceipt)) {
+                await safeUnlink(stageAbsolutePath);
+                throw new VaultError("OPERATION_PRECONDITION_FAILED", `Raw source for "${normalizedTarget}" changed after it was inspected.`, { relativePath: normalizedTarget });
+            }
+        }
         this.record.actions.push({
             kind: "raw_copy",
             state: "staged",
@@ -932,6 +1221,9 @@ export class WriteBatch {
             allowExistingMatch,
             originalFileName,
             mediaType,
+            expectedSourceReceipt: expectedSourceReceipt
+                ? { ...expectedSourceReceipt }
+                : undefined,
         });
         await this.persist();
         return {
@@ -996,6 +1288,9 @@ export class WriteBatch {
     }
     async stageTextWrite(targetRelativePath, content, options = {}) {
         this.assertMutable();
+        if (options.expectedTargetReceipt && options.overwrite === false) {
+            throw new VaultError("OPERATION_PRECONDITION_INVALID", "Receipt-guarded text writes must replace the inspected target.", { relativePath: targetRelativePath });
+        }
         const normalizedTarget = normalizeRelativeVaultPath(targetRelativePath);
         await assertWriteTargetPolicyForVault(this.vaultRoot, normalizedTarget, {
             kind: "text",
@@ -1018,11 +1313,31 @@ export class WriteBatch {
             overwrite: options.overwrite ?? true,
             allowExistingMatch: options.allowExistingMatch ?? false,
             allowRaw: options.allowRaw ?? false,
+            expectedTargetReceipt: options.expectedTargetReceipt
+                ? { ...options.expectedTargetReceipt }
+                : undefined,
         });
         await this.persist();
         return normalizedTarget;
     }
     async stageJsonlAppend(targetRelativePath, content) {
+        return await this.stageJsonlAppendAction(targetRelativePath, content, false);
+    }
+    async stageIntegrationIngestAppendPlan(plan) {
+        this.assertMutable();
+        assertAuthorizedIntegrationIngestAppendPlan(plan);
+        const archivedAmendmentShardPaths = new Set(plan.archivedAmendmentShardPaths);
+        for (const relativePath of [...plan.payloads.keys()].sort()) {
+            const payload = plan.payloads.get(relativePath);
+            if (payload) {
+                const archivedAmendment = archivedAmendmentShardPaths.has(relativePath);
+                await this.stageJsonlAppendAction(relativePath, archivedAmendment
+                    ? payload
+                    : await prepareLiveIntegrationIngestAppendPayload(this.vaultRoot, relativePath, payload), archivedAmendment);
+            }
+        }
+    }
+    async stageJsonlAppendAction(targetRelativePath, content, allowArchivedIntegrationIngestAmendment) {
         this.assertMutable();
         const normalizedTarget = normalizeRelativeVaultPath(targetRelativePath);
         await assertWriteTargetPolicyForVault(this.vaultRoot, normalizedTarget, {
@@ -1036,11 +1351,14 @@ export class WriteBatch {
         const stageAbsolutePath = resolveVaultPath(this.vaultRoot, stageRelativePath).absolutePath;
         await ensureDirectory(path.dirname(stageAbsolutePath));
         await fs.writeFile(stageAbsolutePath, content, "utf8");
+        const stagedPayloadReceipt = createCommittedPayloadReceipt(content);
         this.record.actions.push({
             kind: "jsonl_append",
             state: "staged",
             targetRelativePath: normalizedTarget,
             stageRelativePath,
+            stagedPayloadReceipt,
+            allowArchivedIntegrationIngestAmendment,
         });
         await this.persist();
         return normalizedTarget;
@@ -1062,6 +1380,9 @@ export class WriteBatch {
             state: "staged",
             targetRelativePath: normalizedTarget,
             allowRaw: options.allowRaw ?? false,
+            expectedTargetReceipt: options.expectedTargetReceipt
+                ? { ...options.expectedTargetReceipt }
+                : undefined,
         });
         await this.persist();
         return normalizedTarget;
@@ -1314,6 +1635,9 @@ export class WriteBatch {
             }
             const bytes = await fs.readFile(resolveVaultPath(this.vaultRoot, action.stageRelativePath).absolutePath);
             const receipt = createCommittedPayloadReceipt(bytes);
+            if (action.kind === "raw_copy") {
+                this.assertExpectedSourceReceipt(action, receipt);
+            }
             const existing = payloadsBySha.get(receipt.sha256);
             if (existing) {
                 if (existing.byteLength !== receipt.byteLength) {
@@ -1357,6 +1681,9 @@ export class WriteBatch {
                     baseSha256: baseContentReceipt.sha256,
                     baseByteLength: baseContentReceipt.byteLength,
                     originalSize: action.originalSize ?? null,
+                    ...(action.allowArchivedIntegrationIngestAmendment
+                        ? { allowArchivedIntegrationIngestAmendment: true }
+                        : {}),
                     contentRef: createHostedCanonicalWriteReceiptContentRef(payloadReceipt),
                 };
             }
@@ -1374,10 +1701,21 @@ export class WriteBatch {
                 };
             }
             case "delete":
+                if (action.expectedTargetReceipt) {
+                    return {
+                        kind: "delete_if_match",
+                        targetRelativePath: action.targetRelativePath,
+                        existedBefore: action.existedBefore ?? false,
+                        expectedSha256: action.expectedTargetReceipt.sha256,
+                        expectedByteLength: action.expectedTargetReceipt.byteLength,
+                        ...(action.allowRaw ? { allowRaw: true } : {}),
+                    };
+                }
                 return {
                     kind: "delete",
                     targetRelativePath: action.targetRelativePath,
                     existedBefore: action.existedBefore ?? false,
+                    ...(action.allowRaw ? { allowRaw: true } : {}),
                 };
         }
     }
@@ -1386,7 +1724,11 @@ export class WriteBatch {
     }
     async createActionPayloadReceiptFromStage(action) {
         const stageAbsolutePath = resolveVaultPath(this.vaultRoot, action.stageRelativePath).absolutePath;
-        return createCommittedPayloadReceipt(await fs.readFile(stageAbsolutePath));
+        const receipt = createCommittedPayloadReceipt(await fs.readFile(stageAbsolutePath));
+        if (action.kind === "raw_copy") {
+            this.assertExpectedSourceReceipt(action, receipt);
+        }
+        return receipt;
     }
     async applyAction(index, action) {
         if (action.kind === "raw_copy") {
@@ -1438,6 +1780,146 @@ export class WriteBatch {
             relativePath: action.targetRelativePath,
         });
     }
+    assertExpectedSourceReceipt(action, actualReceipt) {
+        if (action.expectedSourceReceipt
+            && !receiptsMatch(actualReceipt, action.expectedSourceReceipt)) {
+            throw new VaultError("OPERATION_PRECONDITION_FAILED", `Raw source for "${action.targetRelativePath}" changed after it was inspected.`, {
+                operationId: this.operationId,
+                relativePath: action.targetRelativePath,
+            });
+        }
+    }
+    async assertExpectedTargetReceipt(action, absolutePath) {
+        if (!action.expectedTargetReceipt) {
+            return;
+        }
+        let actualReceipt;
+        try {
+            actualReceipt = await createFileContentReceipt(absolutePath);
+        }
+        catch (error) {
+            if (!isErrnoException(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            throw new VaultError("OPERATION_PRECONDITION_FAILED", `Write target "${action.targetRelativePath}" disappeared after it was inspected.`, {
+                operationId: this.operationId,
+                relativePath: action.targetRelativePath,
+            });
+        }
+        if (!receiptsMatch(actualReceipt, action.expectedTargetReceipt)) {
+            throw new VaultError("OPERATION_PRECONDITION_FAILED", `Write target "${action.targetRelativePath}" changed after it was inspected.`, {
+                operationId: this.operationId,
+                relativePath: action.targetRelativePath,
+            });
+        }
+    }
+    async moveExpectedTargetToBackup(action, targetAbsolutePath) {
+        if (!action.expectedTargetReceipt || !action.backupRelativePath) {
+            throw new VaultError("OPERATION_PRECONDITION_INVALID", `Write target "${action.targetRelativePath}" has incomplete precondition metadata.`, {
+                operationId: this.operationId,
+                relativePath: action.targetRelativePath,
+            });
+        }
+        const backupAbsolutePath = resolveVaultPath(this.vaultRoot, action.backupRelativePath).absolutePath;
+        const backupExists = await pathExists(backupAbsolutePath);
+        if (backupExists) {
+            if (await pathExists(targetAbsolutePath)) {
+                throw new VaultError("OPERATION_PRECONDITION_FAILED", `Write target "${action.targetRelativePath}" was recreated while its inspected bytes were quarantined.`, {
+                    operationId: this.operationId,
+                    relativePath: action.targetRelativePath,
+                });
+            }
+        }
+        else {
+            await ensureDirectory(path.dirname(backupAbsolutePath));
+            try {
+                await fs.rename(targetAbsolutePath, backupAbsolutePath);
+            }
+            catch (error) {
+                if (!isErrnoException(error) || error.code !== "ENOENT") {
+                    throw error;
+                }
+                throw new VaultError("OPERATION_PRECONDITION_FAILED", `Write target "${action.targetRelativePath}" disappeared after it was inspected.`, {
+                    operationId: this.operationId,
+                    relativePath: action.targetRelativePath,
+                });
+            }
+        }
+        await this.assertExpectedTargetReceipt(action, backupAbsolutePath);
+        return backupAbsolutePath;
+    }
+    async restoreExpectedTargetFromBackup(action) {
+        if (!action.expectedTargetReceipt || !action.backupRelativePath) {
+            return false;
+        }
+        const backupAbsolutePath = resolveVaultPath(this.vaultRoot, action.backupRelativePath).absolutePath;
+        if (!(await pathExists(backupAbsolutePath))) {
+            return false;
+        }
+        const targetAbsolutePath = resolveVaultPath(this.vaultRoot, action.targetRelativePath).absolutePath;
+        const backupReceipt = await createFileContentReceipt(backupAbsolutePath);
+        if (action.kind === "delete") {
+            if (await pathExists(targetAbsolutePath)) {
+                const targetReceipt = await createFileContentReceipt(targetAbsolutePath);
+                if (receiptsMatch(backupReceipt, targetReceipt)) {
+                    return true;
+                }
+                throw new VaultError("OPERATION_ROLLBACK_CONFLICT", `Write target "${action.targetRelativePath}" was recreated before rollback; its quarantined bytes were retained.`, {
+                    operationId: this.operationId,
+                    relativePath: action.targetRelativePath,
+                });
+            }
+        }
+        else {
+            const replacementRelativePath = `${action.backupRelativePath}.replacement`;
+            const replacementAbsolutePath = resolveVaultPath(this.vaultRoot, replacementRelativePath).absolutePath;
+            if (await pathExists(targetAbsolutePath)) {
+                const targetReceipt = await createFileContentReceipt(targetAbsolutePath);
+                if (receiptsMatch(backupReceipt, targetReceipt)) {
+                    return true;
+                }
+                if (await pathExists(replacementAbsolutePath)) {
+                    throw new VaultError("OPERATION_ROLLBACK_CONFLICT", `Text target "${action.targetRelativePath}" and its replacement quarantine both exist; all bytes were retained.`, {
+                        operationId: this.operationId,
+                        relativePath: action.targetRelativePath,
+                    });
+                }
+                await ensureDirectory(path.dirname(replacementAbsolutePath));
+                await fs.rename(targetAbsolutePath, replacementAbsolutePath);
+            }
+            if (await pathExists(replacementAbsolutePath)) {
+                const replacementReceipt = await createFileContentReceipt(replacementAbsolutePath);
+                if (!action.committedPayloadReceipt
+                    || !receiptsMatch(replacementReceipt, action.committedPayloadReceipt)) {
+                    try {
+                        await copyFileAtomicExclusive(replacementAbsolutePath, targetAbsolutePath);
+                    }
+                    catch (error) {
+                        throw new VaultError("OPERATION_ROLLBACK_CONFLICT", `Text target "${action.targetRelativePath}" changed during rollback; the changed bytes and original backup were retained.`, {
+                            cause: error instanceof Error ? error.message : String(error),
+                            operationId: this.operationId,
+                            relativePath: action.targetRelativePath,
+                        });
+                    }
+                    throw new VaultError("OPERATION_ROLLBACK_CONFLICT", `Text target "${action.targetRelativePath}" changed before rollback; the changed bytes and original backup were retained.`, {
+                        operationId: this.operationId,
+                        relativePath: action.targetRelativePath,
+                    });
+                }
+            }
+        }
+        try {
+            await copyFileAtomicExclusive(backupAbsolutePath, targetAbsolutePath);
+        }
+        catch (error) {
+            throw new VaultError("OPERATION_ROLLBACK_CONFLICT", `Write target "${action.targetRelativePath}" was recreated during rollback; its quarantined bytes were retained.`, {
+                cause: error instanceof Error ? error.message : String(error),
+                operationId: this.operationId,
+                relativePath: action.targetRelativePath,
+            });
+        }
+        return true;
+    }
     getPreparedJsonlBaseReceipt(action) {
         if (action.baseContentReceipt) {
             return action.baseContentReceipt;
@@ -1449,7 +1931,11 @@ export class WriteBatch {
     }
     async applyRawCopy(action) {
         const stageAbsolutePath = resolveVaultPath(this.vaultRoot, action.stageRelativePath).absolutePath;
-        const stagedContent = await fs.readFile(stageAbsolutePath);
+        const [stagedContent, stagedStats] = await Promise.all([
+            fs.readFile(stageAbsolutePath),
+            fs.stat(stageAbsolutePath),
+        ]);
+        this.assertExpectedSourceReceipt(action, createCommittedPayloadReceipt(stagedContent));
         await this.applyPreparedAction({
             action,
             finalize: (result) => {
@@ -1473,7 +1959,9 @@ export class WriteBatch {
             mutateTarget: async (target) => await applyImmutableWriteTarget({
                 allowExistingMatch: action.allowExistingMatch,
                 createEffect: "copy",
-                createTarget: () => copyFileAtomicExclusive(stageAbsolutePath, target.absolutePath),
+                createTarget: () => writeBytesFileAtomicExclusive(target.absolutePath, stagedContent, {
+                    mode: stagedStats.mode & 0o7777,
+                }),
                 existsErrorMessage: "Raw target already exists and may not be overwritten.",
                 matchesExistingContent: async () => {
                     const existingContent = await fs.readFile(target.absolutePath);
@@ -1525,9 +2013,39 @@ export class WriteBatch {
                 return undefined;
             },
             mutateTarget: async (target) => {
-                if (action.existedBefore === true && action.overwrite && !(await pathExists(target.absolutePath))) {
+                if (!action.expectedTargetReceipt
+                    &&
+                        action.existedBefore === true
+                    && action.overwrite
+                    && !(await pathExists(target.absolutePath))) {
                     throw this.buildResumeConflictError(action, `Text target "${action.targetRelativePath}" disappeared while resuming the write batch.`);
                 }
+                if (action.expectedTargetReceipt) {
+                    if (!action.overwrite || !action.backupRelativePath) {
+                        throw new VaultError("OPERATION_PRECONDITION_INVALID", `Receipt-guarded text target "${action.targetRelativePath}" has incomplete replacement metadata.`, {
+                            operationId: this.operationId,
+                            relativePath: action.targetRelativePath,
+                        });
+                    }
+                    const backupAbsolutePath = await this.moveExpectedTargetToBackup(action, target.absolutePath);
+                    const replacementMode = (await fs.stat(backupAbsolutePath)).mode & 0o7777;
+                    try {
+                        await writeBytesFileAtomicExclusive(target.absolutePath, Buffer.from(stagedContent, "utf8"), { mode: replacementMode });
+                    }
+                    catch (error) {
+                        if (!isErrnoException(error) || error.code !== "EEXIST") {
+                            throw error;
+                        }
+                        throw new VaultError("OPERATION_PRECONDITION_FAILED", `Text target "${action.targetRelativePath}" was recreated while its inspected bytes were quarantined.`, {
+                            operationId: this.operationId,
+                            relativePath: action.targetRelativePath,
+                        });
+                    }
+                    return {
+                        effect: "update",
+                        existedBefore: true,
+                    };
+                }
                 return await applyTextWriteTarget({
                     allowExistingMatch: action.allowExistingMatch,
                     backupExisting: action.overwrite
@@ -1574,7 +2092,10 @@ export class WriteBatch {
                     }
                     return changed;
                 });
-                if (action.overwrite && existedBefore && backupRelativePath) {
+                if (action.overwrite
+                    && existedBefore
+                    && backupRelativePath
+                    && !action.expectedTargetReceipt) {
                     await this.ensureBackupArtifactExists(target.absolutePath, backupRelativePath);
                 }
             },
@@ -1586,6 +2107,9 @@ export class WriteBatch {
         const payload = await readText(stageAbsolutePath);
         const payloadBytes = Buffer.from(payload, "utf8");
         const payloadReceipt = action.committedPayloadReceipt ?? createCommittedPayloadReceipt(payloadBytes);
+        const comparisonOptions = {
+            caseInsensitive: await isVaultFilesystemCaseInsensitive(this.vaultRoot),
+        };
         await this.applyPreparedAction({
             action,
             finalize: (result) => {
@@ -1600,6 +2124,34 @@ export class WriteBatch {
                     return undefined;
                 }
                 const baseContentReceipt = this.getPreparedJsonlBaseReceipt(action);
+                if (action.allowArchivedIntegrationIngestAmendment) {
+                    const archived = await readArchivedIntegrationIngestShardText(this.vaultRoot, action.targetRelativePath);
+                    if (archived) {
+                        const targetContent = Buffer.from(archived.content, "utf8");
+                        if (targetContent.byteLength < action.originalSize) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" changed unexpectedly while resuming the write batch.`);
+                        }
+                        const actualBaseReceipt = createCommittedPayloadReceipt(targetContent.subarray(0, action.originalSize));
+                        if (!receiptsMatch(actualBaseReceipt, baseContentReceipt)) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" base content changed while resuming the write batch.`);
+                        }
+                        if (targetContent.byteLength === action.originalSize) {
+                            return undefined;
+                        }
+                        const expectedSize = action.originalSize + payloadBytes.byteLength;
+                        if (targetContent.byteLength !== expectedSize) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" changed unexpectedly while resuming the write batch.`);
+                        }
+                        if (!targetContent.subarray(action.originalSize).equals(payloadBytes)) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" changed unexpectedly while resuming the write batch.`);
+                        }
+                        return {
+                            effect: "append",
+                            existedBefore: true,
+                            originalSize: action.originalSize,
+                        };
+                    }
+                }
                 if (!(await pathExists(target.absolutePath))) {
                     if (action.existedBefore) {
                         throw this.buildResumeConflictError(action, `Append target "${action.targetRelativePath}" disappeared while resuming the write batch.`);
@@ -1631,12 +2183,71 @@ export class WriteBatch {
                     originalSize: action.originalSize,
                 };
             },
-            mutateTarget: async (target) => await applyJsonlAppendTarget({
-                appendPayload: (payloadChunk) => fs.appendFile(target.absolutePath, payloadChunk, "utf8"),
-                readPayload: async () => payload,
-                target,
-            }),
+            mutateTarget: async (target) => {
+                try {
+                    return await applyJsonlAppendTarget({
+                        appendPayload: (payloadChunk) => fs.appendFile(target.absolutePath, payloadChunk, "utf8"),
+                        readPayload: async () => payload,
+                        target,
+                    });
+                }
+                catch (error) {
+                    if (action.allowArchivedIntegrationIngestAmendment &&
+                        isArchivedIntegrationIngestAppendError(error, target, comparisonOptions)) {
+                        const baseContentReceipt = action.baseContentReceipt;
+                        if (!baseContentReceipt) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" is missing its prepared base receipt.`);
+                        }
+                        const result = await appendArchivedIntegrationIngestShard({
+                            expectedBaseByteLength: baseContentReceipt.byteLength,
+                            expectedBaseSha256: baseContentReceipt.sha256,
+                            payload,
+                            targetRelativePath: action.targetRelativePath,
+                            vaultRoot: this.vaultRoot,
+                        });
+                        return {
+                            effect: "append",
+                            existedBefore: true,
+                            originalSize: result.originalSize,
+                        };
+                    }
+                    throw error;
+                }
+            },
             prepareMutation: async (target) => {
+                if (action.allowArchivedIntegrationIngestAmendment) {
+                    const archived = await readArchivedIntegrationIngestShardText(this.vaultRoot, action.targetRelativePath);
+                    if (archived) {
+                        const archivedContent = Buffer.from(archived.content, "utf8");
+                        const originalSize = action.originalSize ?? archivedContent.byteLength;
+                        const baseContentReceipt = action.baseContentReceipt ??
+                            createCommittedPayloadReceipt(archivedContent);
+                        if (baseContentReceipt.byteLength !== originalSize) {
+                            throw this.buildResumeConflictError(action, `Archived append target "${action.targetRelativePath}" base size changed while preparing the write batch.`);
+                        }
+                        await this.persistPreparedAction(() => {
+                            let changed = false;
+                            if (action.baseContentReceipt === undefined) {
+                                action.baseContentReceipt = baseContentReceipt;
+                                changed = true;
+                            }
+                            if (action.committedPayloadReceipt === undefined) {
+                                action.committedPayloadReceipt = payloadReceipt;
+                                changed = true;
+                            }
+                            if (action.existedBefore === undefined) {
+                                action.existedBefore = true;
+                                changed = true;
+                            }
+                            if (action.originalSize === undefined) {
+                                action.originalSize = originalSize;
+                                changed = true;
+                            }
+                            return changed;
+                        });
+                        return;
+                    }
+                }
                 const existedBefore = action.existedBefore ?? (await pathExists(target.absolutePath));
                 const originalSize = action.originalSize ?? (existedBefore ? (await fs.stat(target.absolutePath)).size : 0);
                 const baseContentReceipt = action.baseContentReceipt ??
@@ -1703,6 +2314,9 @@ export class WriteBatch {
                 if (!(await pathExists(backupAbsolutePath))) {
                     throw this.buildResumeConflictError(action, `Delete backup "${action.backupRelativePath}" is missing while resuming the write batch.`);
                 }
+                if (action.expectedTargetReceipt) {
+                    await this.assertExpectedTargetReceipt(action, backupAbsolutePath);
+                }
                 return {
                     backupRelativePath: action.backupRelativePath,
                     existedBefore: true,
@@ -1712,12 +2326,23 @@ export class WriteBatch {
             mutateTarget: async (target) => {
                 const existedBefore = await pathExists(target.absolutePath);
                 if (!existedBefore) {
+                    if (action.expectedTargetReceipt) {
+                        await this.assertExpectedTargetReceipt(action, target.absolutePath);
+                    }
                     return {
                         existedBefore: false,
                         state: "reused",
                     };
                 }
                 const backupRelativePath = this.resolveActionBackupRelativePath(index, action);
+                if (action.expectedTargetReceipt) {
+                    await this.moveExpectedTargetToBackup(action, target.absolutePath);
+                    return {
+                        backupRelativePath,
+                        existedBefore: true,
+                        state: "applied",
+                    };
+                }
                 await this.ensureBackupArtifactExists(target.absolutePath, backupRelativePath);
                 await fs.unlink(target.absolutePath);
                 return {
@@ -1743,7 +2368,9 @@ export class WriteBatch {
                     }
                     return changed;
                 });
-                await this.ensureBackupArtifactExists(target.absolutePath, backupRelativePath);
+                if (!action.expectedTargetReceipt) {
+                    await this.ensureBackupArtifactExists(target.absolutePath, backupRelativePath);
+                }
             },
             prepareTarget: async () => await prepareVerifiedDeleteTarget(this.vaultRoot, action.targetRelativePath, {
                 kind: "delete",
@@ -1753,6 +2380,13 @@ export class WriteBatch {
     }
     async rollbackAppliedActions() {
         for (const action of [...this.record.actions].reverse()) {
+            if ((action.kind === "delete" || action.kind === "text_write")
+                && action.expectedTargetReceipt
+                && await this.restoreExpectedTargetFromBackup(action)) {
+                action.state = "rolled_back";
+                action.rolledBackAt = nowIso();
+                continue;
+            }
             if (action.state !== "applied") {
                 continue;
             }
@@ -1771,7 +2405,18 @@ export class WriteBatch {
             }
             else if (action.kind === "jsonl_append") {
                 const targetAbsolutePath = resolveVaultPath(this.vaultRoot, action.targetRelativePath).absolutePath;
-                if (!action.existedBefore) {
+                if (action.allowArchivedIntegrationIngestAmendment &&
+                    action.baseContentReceipt &&
+                    action.originalSize !== undefined &&
+                    await readArchivedIntegrationIngestShardText(this.vaultRoot, action.targetRelativePath)) {
+                    await truncateArchivedIntegrationIngestShard({
+                        expectedBaseByteLength: action.originalSize,
+                        expectedBaseSha256: action.baseContentReceipt.sha256,
+                        targetRelativePath: action.targetRelativePath,
+                        vaultRoot: this.vaultRoot,
+                    });
+                }
+                else if (!action.existedBefore) {
                     await safeUnlink(targetAbsolutePath);
                 }
                 else {