@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/inboxd/dist/indexing/persist.js

@@ -2,15 +2,15 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { assertContract, inboxCaptureRecordSchema, } from "@murphai/contracts";
-import { acquireCanonicalWriteLock, applyCanonicalWriteBatch, loadVault, listWriteOperationMetadataPaths, readJsonlRecords, readStoredWriteOperation, VAULT_LAYOUT, walkVaultFiles, withCanonicalWriteLockScope, } from "@murphai/core";
+import { assertContract, INBOX_CAPTURE_TEXT_MAX_LENGTH, inboxCaptureRecordSchema, } from "@murphai/contracts";
+import { acquireCanonicalWriteLock, applyCanonicalWriteBatch, loadVault, listWriteOperationMetadataPathsWithStageDirectories, readJsonlRecords, readStoredWriteOperation, readStoredWriteOperationJsonlAppendPayload, VAULT_LAYOUT, walkVaultFiles, withCanonicalWriteLockScope, } from "@murphai/core";
 import { buildAttachmentId, createDeterministicInboxCaptureId, createInboxCaptureIdentityKey, normalizeStoredAttachments, normalizeRelativePath, resolveVaultPath, sanitizeFileName, } from "../shared.js";
 import { replaceInboxCaptureProjection, } from "../kernel/sqlite.js";
 import { buildInboxCaptureDirectory, buildInboxEnvelopePath, buildUnstoredAttachment, stripEphemeralAttachmentFields, } from "./capture-shape.js";
-import { INBOX_CAPTURE_LEDGER_DIRECTORY, buildInboxCaptureLedgerPathForOccurredAt, buildInboxCaptureRecord, } from "./persist/canonical-records.js";
+import { INBOX_CAPTURE_LEDGER_DIRECTORY, buildInboxCaptureLedgerPathForOccurredAt, buildLegacyInboxCaptureRecord, prepareInboxCaptureRecord, } from "./persist/canonical-records.js";
 import { normalizeAttachmentForStorage } from "./attachment-storage-normalizer.js";
 import { normalizeRawMetadataForStorage } from "./raw-metadata-storage-normalizer.js";
-import { listInboxParserManifestPathsNewestFirst } from "./parser-derivatives.js";
+import { listInboxParserArtifactPathsNewestFirst } from "./parser-derivatives.js";
 import { listInboxAttachmentRetentionRecords } from "./retention.js";
 const MAX_INBOX_CAPTURE_ATTACHMENT_COUNT = 64;
 const MAX_INBOX_CAPTURE_ATTACHMENT_BYTES = 128 * 1024 * 1024;
@@ -195,31 +195,14 @@ async function prepareRawCapturePersistence({ captureId, eventId, input, storedA
             }
         }
     }
-    const envelopePath = buildInboxEnvelopePath(input, captureId);
     const storedCapture = {
         captureId,
         eventId,
         storedAt,
         sourceDirectory,
-        envelopePath,
         attachments: storedAttachments,
     };
     const sanitizedInput = buildSanitizedInboundCapture(input, storedAttachments);
-    rawContents.push({
-        targetRelativePath: storedCapture.envelopePath,
-        content: `${JSON.stringify({
-            schema: "murph.inbox-envelope.v1",
-            captureId,
-            eventId,
-            storedAt,
-            input: sanitizedInput,
-            stored: storedCapture,
-        }, null, 2)}
-`,
-        originalFileName: "envelope.json",
-        mediaType: "application/json",
-        allowExistingMatch: true,
-    });
     return {
         stored: storedCapture,
         sanitizedInput,
@@ -301,7 +284,7 @@ export async function persistCanonicalInboxCapture({ vaultRoot, captureId, event
         storedAt,
     });
     const capturePath = buildInboxCaptureLedgerPathForOccurredAt(input.occurredAt);
-    const captureRecord = buildInboxCaptureRecord({
+    const preparedRecord = prepareInboxCaptureRecord({
         eventId,
         inbound: prepared.sanitizedInput,
         stored: prepared.stored,
@@ -317,11 +300,11 @@ export async function persistCanonicalInboxCapture({ vaultRoot, captureId, event
             summary: `Persisted inbox capture ${captureId}.`,
             targetIds: [captureId, eventId],
         },
-        rawContents: prepared.rawContents,
+        rawContents: [...prepared.rawContents, ...preparedRecord.rawContents],
         jsonlAppends: [
             {
                 relativePath: capturePath,
-                record: captureRecord,
+                record: preparedRecord.record,
             },
         ],
     });
@@ -329,11 +312,11 @@ export async function persistCanonicalInboxCapture({ vaultRoot, captureId, event
         stored: prepared.stored,
         capture: {
             relativePath: capturePath,
-            record: captureRecord,
+            record: preparedRecord.record,
         },
     };
 }
-export async function findStoredCaptureEnvelope(input) {
+export async function findStoredCaptureSnapshot(input) {
     const captureId = input.captureId ?? createDeterministicInboxCaptureId(input.inbound);
     const storedRecord = await findStoredInboxCaptureRecord({
         vaultRoot: input.vaultRoot,
@@ -342,7 +325,11 @@ export async function findStoredCaptureEnvelope(input) {
     });
     if (storedRecord) {
         const retainedAttachments = await readRetainedAttachmentMap(input.vaultRoot);
-        const envelope = inboxCaptureRecordToStoredCaptureEnvelope(storedRecord, retainedAttachments);
+        const envelope = await inboxCaptureRecordToStoredCaptureSnapshot({
+            record: storedRecord,
+            retainedAttachments,
+            vaultRoot: input.vaultRoot,
+        });
         return {
             ...envelope,
             stored: await hydrateAttachmentParserProjections({
@@ -373,6 +360,11 @@ export async function ensureStoredCaptureCanonicalEvidence(input) {
             if (selectMatchingInboxCaptureRecord(records, identityKey, input.envelope.captureId)) {
                 return;
             }
+            const preparedRecord = prepareInboxCaptureRecord({
+                eventId: input.envelope.eventId,
+                inbound: input.envelope.input,
+                stored: input.envelope.stored,
+            });
             await applyCanonicalWriteBatch({
                 vaultRoot: input.vaultRoot,
                 operationType: "inbox_capture_canonical_evidence",
@@ -384,14 +376,11 @@ export async function ensureStoredCaptureCanonicalEvidence(input) {
                     summary: `Ensured canonical inbox evidence for capture ${input.envelope.captureId}.`,
                     targetIds: [input.envelope.captureId, input.envelope.eventId],
                 },
+                rawContents: preparedRecord.rawContents,
                 jsonlAppends: [
                     {
                         relativePath,
-                        record: buildInboxCaptureRecord({
-                            eventId: input.envelope.eventId,
-                            inbound: input.envelope.input,
-                            stored: input.envelope.stored,
-                        }),
+                        record: preparedRecord.record,
                     },
                 ],
             });
@@ -407,7 +396,11 @@ export async function rebuildRuntimeFromVault(input) {
     const restoredIdentityKeys = new Set();
     const projectionEntries = [];
     for (const record of canonicalRecords) {
-        const envelope = inboxCaptureRecordToStoredCaptureEnvelope(record, retainedAttachments);
+        const envelope = await inboxCaptureRecordToStoredCaptureSnapshot({
+            record,
+            retainedAttachments,
+            vaultRoot: input.vaultRoot,
+        });
         projectionEntries.push({
             captureId: envelope.captureId,
             eventId: envelope.eventId,
@@ -421,7 +414,7 @@ export async function rebuildRuntimeFromVault(input) {
         restoredIdentityKeys.add(record.identityKey);
     }
     const recoverableOperations = await listRecoverableInboxCaptureOperations(input.vaultRoot);
-    const recoveredEnvelopes = await listRecoverableRawCaptureEnvelopes(input.vaultRoot, restoredIdentityKeys, recoverableOperations);
+    const recoveredEnvelopes = await listRecoverableCaptureSnapshots(input.vaultRoot, restoredIdentityKeys, recoverableOperations);
     for (const envelope of recoveredEnvelopes) {
         await ensureStoredCaptureCanonicalEvidence({
             vaultRoot: input.vaultRoot,
@@ -466,15 +459,15 @@ async function hydrateAttachmentParserProjections(input) {
     };
 }
 async function readAttachmentParserProjection(input) {
-    const manifestPaths = await listInboxParserManifestPathsNewestFirst({
+    const artifactPaths = await listInboxParserArtifactPathsNewestFirst({
         attachmentId: input.attachment.attachmentId,
         captureId: input.captureId,
         vaultRoot: input.vaultRoot,
     });
-    for (const manifestPath of manifestPaths) {
-        const projection = await readAttachmentParserProjectionFromManifest({
+    for (const artifactPath of artifactPaths) {
+        const projection = await readAttachmentParserProjectionFromArtifact({
             ...input,
-            manifestPath,
+            artifactPath,
         });
         if (projection) {
             return projection;
@@ -482,11 +475,43 @@ async function readAttachmentParserProjection(input) {
     }
     return null;
 }
-async function readAttachmentParserProjectionFromManifest(input) {
+async function readAttachmentParserProjectionFromArtifact(input) {
+    if (path.posix.basename(input.artifactPath) === "result.json") {
+        try {
+            const { readParserResult } = await import("@murphai/parsers/parser-result");
+            const result = await readParserResult({
+                resultPath: input.artifactPath,
+                vaultRoot: input.vaultRoot,
+            });
+            if (result.artifact.captureId !== input.captureId ||
+                result.artifact.attachmentId !== input.attachment.attachmentId) {
+                return null;
+            }
+            const plainText = result.text.trim();
+            if (!plainText) {
+                return null;
+            }
+            const transcriptOnly = input.attachment.kind === "audio" || input.attachment.kind === "video";
+            return {
+                derivedPath: input.artifactPath,
+                extractedText: transcriptOnly ? null : plainText,
+                parseState: "succeeded",
+                parseUpdatedAt: result.createdAt,
+                parserProviderId: result.providerId,
+                transcriptText: transcriptOnly ? plainText : null,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    if (path.posix.basename(input.artifactPath) !== "manifest.json") {
+        return null;
+    }
     let manifest;
     try {
-        const manifestAbsolutePath = await resolveVaultPath(input.vaultRoot, input.manifestPath);
-        manifest = expectRecord(JSON.parse(await readFile(manifestAbsolutePath, "utf8")), `retained parser manifest at ${input.manifestPath}`);
+        const manifestAbsolutePath = await resolveVaultPath(input.vaultRoot, input.artifactPath);
+        manifest = expectRecord(JSON.parse(await readFile(manifestAbsolutePath, "utf8")), `retained parser manifest at ${input.artifactPath}`);
     }
     catch {
         return null;
@@ -521,7 +546,7 @@ async function readAttachmentParserProjectionFromManifest(input) {
     }
     const transcriptOnly = input.attachment.kind === "audio" || input.attachment.kind === "video";
     return {
-        derivedPath: input.manifestPath,
+        derivedPath: input.artifactPath,
         extractedText: transcriptOnly ? null : plainText,
         parseState: "succeeded",
         parseUpdatedAt: typeof manifest.createdAt === "string" ? manifest.createdAt : input.fallbackUpdatedAt,
@@ -543,10 +568,34 @@ function normalizeParserArtifactPath(input) {
     const attemptsPrefix = path.posix.join("derived/inbox", input.captureId, "attachments", input.attachmentId, "attempts");
     return normalized.startsWith(`${attemptsPrefix}/`) ? normalized : null;
 }
-async function readStoredCaptureEnvelope(input) {
+async function readStoredCaptureSnapshot(input) {
+    const absolutePath = await resolveVaultPath(input.vaultRoot, input.relativePath);
+    try {
+        return normalizeLegacyInboxCaptureSnapshot(JSON.parse(await readFile(absolutePath, "utf8")), input.relativePath);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function readLegacyInboxCaptureRecord(input) {
+    const absolutePath = await resolveVaultPath(input.vaultRoot, input.relativePath);
+    try {
+        return normalizeLegacyInboxCaptureRecord(JSON.parse(await readFile(absolutePath, "utf8")), input.relativePath);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function readLegacyInboxCaptureSnapshot(input) {
     const absolutePath = await resolveVaultPath(input.vaultRoot, input.relativePath);
     try {
-        return normalizeStoredCaptureEnvelope(JSON.parse(await readFile(absolutePath, "utf8")), input.relativePath);
+        return normalizeLegacyInboxCaptureSnapshot(JSON.parse(await readFile(absolutePath, "utf8")), input.relativePath);
     }
     catch (error) {
         if (isMissingFileError(error)) {
@@ -555,7 +604,16 @@ async function readStoredCaptureEnvelope(input) {
         throw error;
     }
 }
-function normalizeStoredCaptureEnvelope(value, relativePath) {
+function normalizeLegacyInboxCaptureRecord(value, relativePath) {
+    const snapshot = normalizeLegacyInboxCaptureSnapshot(value, relativePath);
+    return buildLegacyInboxCaptureRecord({
+        envelopePath: buildInboxEnvelopePath(snapshot.input, snapshot.captureId),
+        eventId: snapshot.eventId,
+        inbound: snapshot.input,
+        stored: snapshot.stored,
+    });
+}
+function normalizeLegacyInboxCaptureSnapshot(value, relativePath) {
     const context = `stored inbox envelope at ${relativePath}`;
     const envelope = expectRecord(value, context);
     if (envelope.schema !== "murph.inbox-envelope.v1") {
@@ -603,18 +661,18 @@ function normalizeStoredCaptureEnvelope(value, relativePath) {
             originalPath: null,
         };
     });
-    return inboxCaptureRecordToStoredCaptureEnvelope(buildInboxCaptureRecord({
+    return {
+        captureId,
         eventId,
-        inbound,
+        input: inbound,
         stored: {
             captureId,
             eventId,
             storedAt,
             sourceDirectory,
-            envelopePath,
             attachments,
         },
-    }));
+    };
 }
 async function readJsonlRecordsIfPresent(input) {
     try {
@@ -629,10 +687,17 @@ async function readJsonlRecordsIfPresent(input) {
         throw error;
     }
 }
-async function listRecoverableRawCaptureEnvelopes(vaultRoot, restoredIdentityKeys, recoverableOperations) {
+async function listRecoverableCaptureSnapshots(vaultRoot, restoredIdentityKeys, recoverableOperations) {
     const selectedByIdentityKey = new Map();
     for (const relativePath of [...recoverableOperations.keys()].sort()) {
-        const envelope = await readRecoverableStoredCaptureEnvelope({ vaultRoot, relativePath });
+        const recoverableOperation = recoverableOperations.get(relativePath);
+        if (!recoverableOperation) {
+            continue;
+        }
+        const envelope = await readRecoverableStoredCaptureSnapshot({
+            vaultRoot,
+            recoverableOperation,
+        });
         if (!envelope) {
             continue;
         }
@@ -642,19 +707,23 @@ async function listRecoverableRawCaptureEnvelopes(vaultRoot, restoredIdentityKey
         }
         const current = selectedByIdentityKey.get(identityKey);
         const candidate = { relativePath, envelope };
-        if (!current || compareEnvelopeEntries(candidate, current) < 0) {
+        if (!current || compareCaptureSnapshotEntries(candidate, current) < 0) {
             selectedByIdentityKey.set(identityKey, candidate);
         }
     }
-    return [...selectedByIdentityKey.values()].sort(compareEnvelopeEntries).map((entry) => entry.envelope);
+    return [...selectedByIdentityKey.values()].sort(compareCaptureSnapshotEntries).map((entry) => entry.envelope);
 }
 async function findRecoverableRawCaptureEnvelope(input) {
     const identityKey = createInboxCaptureIdentityKey(input.inbound);
     let selected = null;
     for (const relativePath of [...input.recoverableOperations.keys()].sort()) {
-        const envelope = await readRecoverableStoredCaptureEnvelope({
+        const recoverableOperation = input.recoverableOperations.get(relativePath);
+        if (!recoverableOperation) {
+            continue;
+        }
+        const envelope = await readRecoverableStoredCaptureSnapshot({
             vaultRoot: input.vaultRoot,
-            relativePath,
+            recoverableOperation,
         });
         if (!envelope) {
             continue;
@@ -664,15 +733,35 @@ async function findRecoverableRawCaptureEnvelope(input) {
             continue;
         }
         const candidate = { relativePath, envelope };
-        if (!selected || compareEnvelopeEntries(candidate, selected) < 0) {
+        if (!selected || compareCaptureSnapshotEntries(candidate, selected) < 0) {
             selected = candidate;
         }
     }
     return selected?.envelope ?? null;
 }
-async function readRecoverableStoredCaptureEnvelope(input) {
+async function readRecoverableStoredCaptureSnapshot(input) {
     try {
-        return await readStoredCaptureEnvelope(input);
+        const stagedPayload = await readStoredWriteOperationJsonlAppendPayload({
+            operation: input.recoverableOperation.operation,
+            targetRelativePath: input.recoverableOperation.capturePath,
+            vaultRoot: input.vaultRoot,
+        });
+        if (stagedPayload) {
+            const record = assertContract(inboxCaptureRecordSchema, JSON.parse(stagedPayload), `recoverable inbox capture at ${input.recoverableOperation.capturePath}`);
+            if (record.schemaVersion === "murph.inbox-capture.v2" &&
+                recoverableInboxCaptureRecordMatchesOperation(record, input.recoverableOperation)) {
+                return await inboxCaptureRecordToStoredCaptureSnapshot({
+                    record,
+                    vaultRoot: input.vaultRoot,
+                });
+            }
+        }
+        return input.recoverableOperation.envelopePath
+            ? await readStoredCaptureSnapshot({
+                vaultRoot: input.vaultRoot,
+                relativePath: input.recoverableOperation.envelopePath,
+            })
+            : null;
     }
     catch (error) {
         if (error instanceof SyntaxError || error instanceof TypeError) {
@@ -682,7 +771,7 @@ async function readRecoverableStoredCaptureEnvelope(input) {
     }
 }
 async function listRecoverableInboxCaptureOperations(vaultRoot) {
-    const relativePaths = await listWriteOperationMetadataPaths(vaultRoot);
+    const relativePaths = await listWriteOperationMetadataPathsWithStageDirectories(vaultRoot);
     const selected = new Map();
     for (const relativePath of relativePaths) {
         let operation;
@@ -696,9 +785,10 @@ async function listRecoverableInboxCaptureOperations(vaultRoot) {
         if (!recoverable) {
             continue;
         }
-        const current = selected.get(recoverable.envelopePath);
+        const selectionKey = `${recoverable.capturePath}\u0000${operation.operationId}`;
+        const current = selected.get(selectionKey);
         if (!current || current.updatedAt.localeCompare(recoverable.updatedAt) < 0) {
-            selected.set(recoverable.envelopePath, recoverable);
+            selected.set(selectionKey, recoverable);
         }
     }
     return selected;
@@ -714,19 +804,56 @@ function selectRecoverableInboxCaptureOperation(operation) {
         action.targetRelativePath.startsWith(`${VAULT_LAYOUT.rawInboxDirectory}/`) &&
         action.targetRelativePath.endsWith("/envelope.json") &&
         (action.state === "applied" || action.state === "reused"));
-    const captureAction = operation.actions.find((action) => action.kind === "jsonl_append" &&
+    const captureActions = operation.actions.filter((action) => action.kind === "jsonl_append" &&
         action.targetRelativePath.startsWith(`${INBOX_CAPTURE_LEDGER_DIRECTORY}/`) &&
         action.state === "staged");
-    if (!envelopeAction || !captureAction) {
+    if (captureActions.length !== 1) {
+        return null;
+    }
+    const captureAction = captureActions[0];
+    if (!captureAction) {
         return null;
     }
     return {
-        envelopePath: envelopeAction.targetRelativePath,
+        envelopePath: envelopeAction?.targetRelativePath ?? null,
         capturePath: captureAction.targetRelativePath,
+        operation,
         updatedAt: operation.updatedAt,
     };
 }
-function compareEnvelopeEntries(left, right) {
+function recoverableInboxCaptureRecordMatchesOperation(record, recoverable) {
+    if (buildInboxCaptureLedgerPathForOccurredAt(record.occurredAt) !==
+        recoverable.capturePath) {
+        return false;
+    }
+    const storedPaths = [
+        ...record.attachments
+            .map((attachment) => attachment.storedPath)
+            .filter((storedPath) => Boolean(storedPath)),
+        ...(record.schemaVersion === "murph.inbox-capture.v2" && record.textContent
+            ? [record.textContent.storedPath]
+            : []),
+    ]
+        .sort();
+    const rawRefs = [
+        ...record.rawRefs,
+        ...(record.schemaVersion === "murph.inbox-capture.v2" && record.textContent
+            ? [record.textContent.storedPath]
+            : []),
+    ].sort();
+    if (storedPaths.length !== rawRefs.length ||
+        storedPaths.some((storedPath, index) => storedPath !== rawRefs[index])) {
+        return false;
+    }
+    const appliedRawPaths = recoverable.operation.actions
+        .filter((action) => action.kind === "raw_copy" &&
+        (action.state === "applied" || action.state === "reused"))
+        .map((action) => action.targetRelativePath)
+        .sort();
+    return (appliedRawPaths.length === storedPaths.length &&
+        appliedRawPaths.every((storedPath, index) => storedPath === storedPaths[index]));
+}
+function compareCaptureSnapshotEntries(left, right) {
     const storedAtComparison = left.envelope.stored.storedAt.localeCompare(right.envelope.stored.storedAt);
     if (storedAtComparison !== 0) {
         return storedAtComparison;
@@ -737,8 +864,10 @@ function compareEnvelopeEntries(left, right) {
     }
     return left.relativePath.localeCompare(right.relativePath);
 }
-function inboxCaptureRecordToStoredCaptureEnvelope(record, retainedAttachments = new Map()) {
-    const input = {
+async function inboxCaptureRecordToStoredCaptureSnapshot(options) {
+    const { record } = options;
+    const retainedAttachments = options.retainedAttachments ?? new Map();
+    const captureInput = {
         source: record.source,
         externalId: record.externalId,
         accountId: record.accountId ?? null,
@@ -754,7 +883,10 @@ function inboxCaptureRecordToStoredCaptureEnvelope(record, retainedAttachments =
         },
         occurredAt: record.occurredAt,
         receivedAt: record.receivedAt ?? null,
-        text: record.text ?? null,
+        text: await readInboxCaptureRecordText({
+            record,
+            vaultRoot: options.vaultRoot,
+        }),
         attachments: record.attachments.map((attachment) => ({
             externalId: attachment.externalId ?? null,
             kind: attachment.kind,
@@ -770,7 +902,6 @@ function inboxCaptureRecordToStoredCaptureEnvelope(record, retainedAttachments =
         eventId: record.eventId,
         storedAt: record.recordedAt,
         sourceDirectory: record.sourceDirectory,
-        envelopePath: record.envelopePath,
         attachments: record.attachments.map((attachment) => {
             const retained = retainedAttachments.get(attachment.attachmentId);
             const retentionExpired = retained?.storedPath === attachment.storedPath;
@@ -790,14 +921,33 @@ function inboxCaptureRecordToStoredCaptureEnvelope(record, retainedAttachments =
         }),
     };
     return {
-        schema: "murph.inbox-envelope.v1",
         captureId: record.captureId,
         eventId: record.eventId,
-        storedAt: record.recordedAt,
-        input,
+        input: captureInput,
         stored,
     };
 }
+async function readInboxCaptureRecordText(input) {
+    const projection = input.record.text ?? null;
+    if (input.record.schemaVersion !== "murph.inbox-capture.v2"
+        || !input.record.textContent) {
+        return projection;
+    }
+    if (projection === null || projection.length !== INBOX_CAPTURE_TEXT_MAX_LENGTH) {
+        throw new TypeError(`Inbox capture text content requires an ${INBOX_CAPTURE_TEXT_MAX_LENGTH}-character inline projection.`);
+    }
+    const expectedPath = path.posix.join(input.record.sourceDirectory, "text.txt");
+    if (input.record.textContent.storedPath !== expectedPath) {
+        throw new TypeError("Inbox capture text content path does not match its source directory.");
+    }
+    const bytes = await readFile(await resolveVaultPath(input.vaultRoot, input.record.textContent.storedPath));
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    if (bytes.byteLength !== input.record.textContent.byteSize
+        || sha256 !== input.record.textContent.sha256) {
+        throw new TypeError("Inbox capture text content bytes do not match the canonical record.");
+    }
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}
 async function readInboxCaptureRecordsIfPresent(input) {
     const records = await readJsonlRecordsIfPresent(input);
     return records.map((record, index) => assertContract(inboxCaptureRecordSchema, record, `inbox capture record at ${input.relativePath}#${index + 1}`));
@@ -865,11 +1015,14 @@ function compareInboxCaptureRecords(left, right) {
     if (recordedAtComparison !== 0) {
         return recordedAtComparison;
     }
+    if (left.schemaVersion !== right.schemaVersion) {
+        return left.schemaVersion === "murph.inbox-capture.v2" ? -1 : 1;
+    }
     const captureComparison = left.captureId.localeCompare(right.captureId);
     if (captureComparison !== 0) {
         return captureComparison;
     }
-    return left.envelopePath.localeCompare(right.envelopePath);
+    return left.sourceDirectory.localeCompare(right.sourceDirectory);
 }
 function normalizeStoredCaptureInboundInput(value, context) {
     const input = expectRecord(value, context);