@murphai/hosted-execution 0.1.15 → 0.1.17

package/node_modules/@murphai/core/dist/vault.js

@@ -0,0 +1,649 @@
+import path from "node:path";
+import { allergyFrontmatterSchema, assessmentResponseSchema, conditionFrontmatterSchema, auditRecordSchema, coreFrontmatterSchema, eventRecordSchema, experimentFrontmatterSchema, familyMemberFrontmatterSchema, foodFrontmatterSchema, geneticVariantFrontmatterSchema, goalFrontmatterSchema, journalDayFrontmatterSchema, profileCurrentFrontmatterSchema, profileSnapshotSchema, rawImportManifestSchema, recipeFrontmatterSchema, protocolFrontmatterSchema, safeParseContract, sampleRecordSchema, vaultMetadataSchema, workoutFormatFrontmatterSchema, } from "@murphai/contracts";
+import { DEFAULT_TIMEZONE, REQUIRED_DIRECTORIES, VAULT_LAYOUT, } from "./constants.js";
+import { emitAuditRecord } from "./audit.js";
+import { ensureDirectory, ensureVaultDirectory, pathExists, readJsonFile, readUtf8File, walkVaultFiles, } from "./fs.js";
+import { VaultError } from "./errors.js";
+import { parseFrontmatterDocument } from "./frontmatter.js";
+import { generateVaultId } from "./ids.js";
+import { readJsonlRecords } from "./jsonl.js";
+import { normalizeVaultRoot, resolveVaultPath } from "./path-safety.js";
+import { isTerminalWriteOperationStatus, listWriteOperationMetadataPaths, readStoredWriteOperation, runCanonicalWrite, } from "./operations/write-batch.js";
+import { buildCurrentProfileMarkdown, listProfileSnapshots, readCurrentProfileMarkdown, stageCurrentProfileMaterialization, } from "./profile/storage.js";
+import { toIsoTimestamp } from "./time.js";
+import { buildVaultCoreDocument } from "./vault-core-document.js";
+import { buildVaultMetadata, loadVaultMetadata, } from "./vault-metadata.js";
+import { isPlainRecord } from "./types.js";
+function assertContractShape(schema, value, code, message) {
+    const result = safeParseContract(schema, value);
+    if (!result.success) {
+        throw new VaultError(code, message, { errors: result.errors });
+    }
+}
+function validationIssue(code, message, path, severity = "error") {
+    return path ? { code, message, path, severity } : { code, message, severity };
+}
+export async function initializeVault({ vaultRoot, title = "Murph Vault", timezone = DEFAULT_TIMEZONE, createdAt = new Date(), } = {}) {
+    const absoluteRoot = normalizeVaultRoot(vaultRoot);
+    const metadataPath = resolveVaultPath(absoluteRoot, VAULT_LAYOUT.metadata);
+    if (await pathExists(metadataPath.absolutePath)) {
+        throw new VaultError("VAULT_ALREADY_EXISTS", "Vault already exists at the requested root.");
+    }
+    await ensureDirectory(absoluteRoot);
+    for (const relativeDirectory of REQUIRED_DIRECTORIES) {
+        await ensureVaultDirectory(absoluteRoot, relativeDirectory);
+    }
+    const createdTimestamp = toIsoTimestamp(createdAt, "createdAt");
+    const metadata = buildVaultMetadata({
+        vaultId: generateVaultId(),
+        createdAt: createdTimestamp,
+        title,
+        timezone,
+    });
+    assertContractShape(vaultMetadataSchema, metadata, "VAULT_INVALID_METADATA", "Generated vault metadata failed contract validation.");
+    const coreDocument = buildVaultCoreDocument({
+        vaultId: metadata.vaultId,
+        title,
+        timezone,
+        updatedAt: createdTimestamp,
+    });
+    const auditPath = await runCanonicalWrite({
+        vaultRoot: absoluteRoot,
+        operationType: "vault_init",
+        summary: `Initialize vault ${metadata.vaultId}`,
+        occurredAt: createdTimestamp,
+        mutate: async ({ batch }) => {
+            await batch.stageTextWrite(VAULT_LAYOUT.metadata, `${JSON.stringify(metadata, null, 2)}\n`, {
+                overwrite: false,
+            });
+            await batch.stageTextWrite(VAULT_LAYOUT.coreDocument, coreDocument, {
+                overwrite: false,
+            });
+            const audit = await emitAuditRecord({
+                vaultRoot: absoluteRoot,
+                batch,
+                action: "vault_init",
+                commandName: "core.initializeVault",
+                summary: "Initialized vault metadata and core document.",
+                occurredAt: createdTimestamp,
+                files: [VAULT_LAYOUT.metadata, VAULT_LAYOUT.coreDocument],
+                targetIds: [metadata.vaultId],
+            });
+            return audit.relativePath;
+        },
+    });
+    const vault = await loadVault({ vaultRoot: absoluteRoot });
+    return {
+        ...vault,
+        created: true,
+        auditPath,
+    };
+}
+export async function loadVault({ vaultRoot } = {}) {
+    const absoluteRoot = normalizeVaultRoot(vaultRoot);
+    const { metadata } = await loadVaultMetadata(absoluteRoot, "VAULT_INVALID_METADATA", "Vault metadata failed contract validation.");
+    return {
+        vaultRoot: absoluteRoot,
+        metadata,
+        layout: {
+            ...VAULT_LAYOUT,
+        },
+    };
+}
+export async function repairVault({ vaultRoot } = {}) {
+    const absoluteRoot = normalizeVaultRoot(vaultRoot);
+    const { metadata } = await loadVaultMetadata(absoluteRoot, "VAULT_INVALID_METADATA", "Vault metadata failed contract validation.");
+    const createdDirectories = await ensureMissingRequiredDirectories(absoluteRoot);
+    const currentState = await readCurrentProfileMarkdown(absoluteRoot);
+    let latestSnapshot;
+    try {
+        latestSnapshot = (await listProfileSnapshots({ vaultRoot: absoluteRoot })).at(-1) ?? null;
+    }
+    catch {
+        latestSnapshot = undefined;
+    }
+    const currentProfileNeedsRepair = latestSnapshot === undefined
+        ? false
+        : latestSnapshot === null
+            ? currentState.exists
+            : currentState.markdown !== buildCurrentProfileMarkdown(latestSnapshot);
+    if (createdDirectories.length === 0 && !currentProfileNeedsRepair) {
+        return {
+            metadataFile: VAULT_LAYOUT.metadata,
+            title: metadata.title,
+            timezone: metadata.timezone,
+            createdDirectories,
+            updated: false,
+            auditPath: null,
+        };
+    }
+    let auditPath = null;
+    const occurredAt = new Date().toISOString();
+    auditPath = await runCanonicalWrite({
+        vaultRoot: absoluteRoot,
+        operationType: "vault_repair",
+        summary: `Repair vault ${metadata.vaultId}`,
+        occurredAt,
+        mutate: async ({ batch }) => {
+            const repairSummaries = [];
+            const repairFiles = [...createdDirectories];
+            const repairTargetIds = [metadata.vaultId];
+            if (createdDirectories.length > 0) {
+                repairSummaries.push("Created missing required scaffold directories.");
+            }
+            if (latestSnapshot !== undefined) {
+                const materialized = await stageCurrentProfileMaterialization(batch, currentState, latestSnapshot);
+                if (materialized.updated) {
+                    const rebuildAudit = materialized.rebuildAudit;
+                    const rebuildChanges = rebuildAudit.changes ?? [];
+                    const rebuildTargetIds = rebuildAudit.targetIds ?? [];
+                    repairSummaries.push(rebuildAudit.summary ?? "Rebuilt current profile from snapshot.");
+                    if (rebuildChanges.length > 0) {
+                        repairFiles.push(...rebuildChanges.map((change) => change.path));
+                    }
+                    if (rebuildTargetIds.length > 0) {
+                        repairTargetIds.push(...rebuildTargetIds);
+                    }
+                }
+            }
+            const audit = await emitAuditRecord({
+                vaultRoot: absoluteRoot,
+                batch,
+                action: "vault_repair",
+                commandName: "core.repairVault",
+                summary: repairSummaries.join(" "),
+                occurredAt,
+                files: repairFiles,
+                targetIds: repairTargetIds,
+            });
+            return audit.relativePath;
+        },
+    });
+    return {
+        metadataFile: VAULT_LAYOUT.metadata,
+        title: metadata.title,
+        timezone: metadata.timezone,
+        createdDirectories,
+        updated: true,
+        auditPath,
+    };
+}
+async function ensureMissingRequiredDirectories(vaultRoot) {
+    const createdDirectories = [];
+    for (const relativeDirectory of REQUIRED_DIRECTORIES) {
+        const directoryPath = resolveVaultPath(vaultRoot, relativeDirectory);
+        if (await pathExists(directoryPath.absolutePath)) {
+            continue;
+        }
+        await ensureVaultDirectory(vaultRoot, relativeDirectory);
+        createdDirectories.push(relativeDirectory);
+    }
+    return createdDirectories;
+}
+async function validateFrontmatterFile({ vaultRoot, relativePath, schema, code, }) {
+    try {
+        const content = await readUtf8File(vaultRoot, relativePath);
+        const parsed = parseFrontmatterDocument(content);
+        const result = safeParseContract(schema, parsed.attributes);
+        if (!result.success) {
+            return [validationIssue(code, result.errors.join("; "), relativePath)];
+        }
+    }
+    catch (error) {
+        return [
+            validationIssue(error instanceof VaultError && error.code === "VAULT_FILE_MISSING" ? error.code : code, error instanceof Error ? error.message : String(error), relativePath),
+        ];
+    }
+    return [];
+}
+async function validateFrontmatterDirectory({ vaultRoot, relativeDirectory, schema, code, }) {
+    const relativePaths = await walkVaultFiles(vaultRoot, relativeDirectory, {
+        extension: ".md",
+    });
+    const issues = [];
+    for (const relativePath of relativePaths) {
+        issues.push(...(await validateFrontmatterFile({
+            vaultRoot,
+            relativePath,
+            schema,
+            code,
+        })));
+    }
+    return issues;
+}
+async function validateJsonlFamily({ vaultRoot, relativeDirectory, schema, code, postValidateRecord, }) {
+    const jsonlFiles = await walkVaultFiles(vaultRoot, relativeDirectory, {
+        extension: ".jsonl",
+    });
+    const issues = [];
+    for (const relativePath of jsonlFiles) {
+        let records;
+        try {
+            records = await readJsonlRecords({
+                vaultRoot,
+                relativePath,
+            });
+        }
+        catch (error) {
+            issues.push(validationIssue(error instanceof VaultError ? error.code : code, error instanceof Error ? error.message : String(error), relativePath));
+            continue;
+        }
+        for (const [index, record] of records.entries()) {
+            const result = safeParseContract(schema, record);
+            if (!result.success) {
+                issues.push(validationIssue(code, `record ${index + 1}: ${result.errors.join("; ")}`, relativePath));
+                continue;
+            }
+            if (postValidateRecord) {
+                issues.push(...(await postValidateRecord(result.data, {
+                    relativePath,
+                    index,
+                })));
+            }
+        }
+    }
+    return issues;
+}
+function rawManifestPathForArtifact(relativePath) {
+    return path.posix.join(path.posix.dirname(relativePath), "manifest.json");
+}
+function isEnvelopeBasedInboxRawPath(relativePath) {
+    return relativePath.startsWith(`${VAULT_LAYOUT.rawDirectory}/inbox/`);
+}
+function inboxCaptureRootForRawPath(relativePath) {
+    if (!isEnvelopeBasedInboxRawPath(relativePath)) {
+        return null;
+    }
+    if (path.posix.basename(relativePath) === "envelope.json") {
+        return path.posix.dirname(relativePath);
+    }
+    const attachmentsMarker = "/attachments/";
+    const attachmentIndex = relativePath.indexOf(attachmentsMarker);
+    if (attachmentIndex !== -1) {
+        return relativePath.slice(0, attachmentIndex);
+    }
+    return null;
+}
+function inboxAttachmentManifestPathForCaptureDirectory(captureDirectory) {
+    return path.posix.join(captureDirectory, "attachments", "manifest.json");
+}
+async function validateExistingVaultFile(vaultRoot, relativePath, code, message) {
+    try {
+        const resolved = resolveVaultPath(vaultRoot, relativePath);
+        if (!(await pathExists(resolved.absolutePath))) {
+            return [validationIssue(code, message, relativePath)];
+        }
+    }
+    catch (error) {
+        return [
+            validationIssue(error instanceof VaultError ? error.code : code, error instanceof Error ? error.message : String(error), relativePath),
+        ];
+    }
+    return [];
+}
+async function validateAssessmentRecordReferences(vaultRoot, record) {
+    const issues = await validateExistingVaultFile(vaultRoot, record.rawPath, "RAW_REFERENCE_MISSING", `Assessment raw payload "${record.rawPath}" is missing.`);
+    issues.push(...(await validateExistingVaultFile(vaultRoot, rawManifestPathForArtifact(record.rawPath), "RAW_MANIFEST_INVALID", `Raw import manifest is missing for "${record.rawPath}".`)));
+    return issues;
+}
+async function validateEventRecordReferences(vaultRoot, record) {
+    const referencedPaths = new Set();
+    if (Array.isArray(record.rawRefs)) {
+        for (const rawRef of record.rawRefs) {
+            if (typeof rawRef === "string") {
+                referencedPaths.add(rawRef);
+            }
+        }
+    }
+    if (typeof record.documentPath === "string") {
+        referencedPaths.add(record.documentPath);
+    }
+    if (Array.isArray(record.photoPaths)) {
+        for (const photoPath of record.photoPaths) {
+            if (typeof photoPath === "string") {
+                referencedPaths.add(photoPath);
+            }
+        }
+    }
+    if (Array.isArray(record.audioPaths)) {
+        for (const audioPath of record.audioPaths) {
+            if (typeof audioPath === "string") {
+                referencedPaths.add(audioPath);
+            }
+        }
+    }
+    const mediaLists = [
+        Array.isArray(record.media)
+            ? (record.media)
+            : [],
+        Array.isArray(record.workout?.media)
+            ? ((record.workout.media))
+            : [],
+    ];
+    for (const mediaList of mediaLists) {
+        for (const media of mediaList) {
+            if (media &&
+                typeof media === "object" &&
+                typeof media.relativePath === "string") {
+                referencedPaths.add(media.relativePath);
+            }
+        }
+    }
+    const issues = [];
+    const manifestPaths = new Set();
+    for (const referencedPath of [...referencedPaths].sort()) {
+        issues.push(...(await validateExistingVaultFile(vaultRoot, referencedPath, "RAW_REFERENCE_MISSING", `Referenced raw artifact "${referencedPath}" is missing.`)));
+        if (referencedPath.startsWith(`${VAULT_LAYOUT.rawDirectory}/`) &&
+            !isEnvelopeBasedInboxRawPath(referencedPath)) {
+            manifestPaths.add(rawManifestPathForArtifact(referencedPath));
+        }
+    }
+    for (const manifestPath of [...manifestPaths].sort()) {
+        issues.push(...(await validateExistingVaultFile(vaultRoot, manifestPath, "RAW_MANIFEST_INVALID", `Raw import manifest is missing for "${manifestPath}".`)));
+    }
+    return issues;
+}
+async function validateRawManifestFile(vaultRoot, relativePath) {
+    let manifest;
+    try {
+        manifest = await readJsonFile(vaultRoot, relativePath);
+    }
+    catch (error) {
+        return [
+            validationIssue(error instanceof VaultError ? error.code : "RAW_MANIFEST_INVALID", error instanceof Error ? error.message : String(error), relativePath),
+        ];
+    }
+    if (!isPlainRecord(manifest)) {
+        return [validationIssue("RAW_MANIFEST_INVALID", "Raw import manifest must be a JSON object.", relativePath)];
+    }
+    const issues = [];
+    const expectedRawDirectory = path.posix.dirname(relativePath);
+    const contractResult = safeParseContract(rawImportManifestSchema, manifest);
+    if (!contractResult.success) {
+        issues.push(...contractResult.errors.map((error) => validationIssue("RAW_MANIFEST_INVALID", `Raw import manifest ${error}.`, relativePath)));
+    }
+    if (typeof manifest.schemaVersion !== "string" || manifest.schemaVersion.trim().length === 0) {
+        issues.push(validationIssue("RAW_MANIFEST_INVALID", "Raw import manifest is missing schemaVersion.", relativePath));
+    }
+    if (manifest.rawDirectory !== expectedRawDirectory) {
+        issues.push(validationIssue("RAW_MANIFEST_INVALID", `Raw import manifest rawDirectory must equal "${expectedRawDirectory}".`, relativePath));
+    }
+    if (!Array.isArray(manifest.artifacts)) {
+        issues.push(validationIssue("RAW_MANIFEST_INVALID", "Raw import manifest must provide an artifacts array.", relativePath));
+        return issues;
+    }
+    for (const [index, artifact] of manifest.artifacts.entries()) {
+        if (!isPlainRecord(artifact) || typeof artifact.relativePath !== "string") {
+            issues.push(validationIssue("RAW_MANIFEST_INVALID", `artifact ${index + 1} is missing a valid relativePath.`, relativePath));
+            continue;
+        }
+        if (path.posix.dirname(artifact.relativePath) !== expectedRawDirectory) {
+            issues.push(validationIssue("RAW_MANIFEST_INVALID", `artifact ${index + 1} must remain inside "${expectedRawDirectory}".`, relativePath));
+        }
+        issues.push(...(await validateExistingVaultFile(vaultRoot, artifact.relativePath, "RAW_REFERENCE_MISSING", `Manifest artifact "${artifact.relativePath}" is missing.`)));
+    }
+    return issues;
+}
+async function validateRawImportManifests(vaultRoot) {
+    const rawFiles = await walkVaultFiles(vaultRoot, VAULT_LAYOUT.rawDirectory);
+    const artifactDirectories = new Set();
+    const inboxCaptureDirectories = new Set();
+    const inboxAttachmentManifestFiles = new Set();
+    const manifestFiles = [];
+    for (const relativePath of rawFiles) {
+        const inboxCaptureDirectory = inboxCaptureRootForRawPath(relativePath);
+        if (inboxCaptureDirectory !== null) {
+            inboxCaptureDirectories.add(inboxCaptureDirectory);
+        }
+        if (path.posix.basename(relativePath) === "manifest.json") {
+            if (isEnvelopeBasedInboxRawPath(relativePath)) {
+                if (relativePath === inboxAttachmentManifestPathForCaptureDirectory(path.posix.dirname(path.posix.dirname(relativePath)))) {
+                    inboxAttachmentManifestFiles.add(relativePath);
+                }
+                continue;
+            }
+            manifestFiles.push(relativePath);
+            continue;
+        }
+        const directory = path.posix.dirname(relativePath);
+        if (isEnvelopeBasedInboxRawPath(directory)) {
+            continue;
+        }
+        artifactDirectories.add(directory);
+    }
+    const issues = [];
+    for (const captureDirectory of [...inboxCaptureDirectories].sort()) {
+        const envelopePath = path.posix.join(captureDirectory, "envelope.json");
+        const attachmentManifestPath = inboxAttachmentManifestPathForCaptureDirectory(captureDirectory);
+        const hasEnvelope = await pathExists(resolveVaultPath(vaultRoot, envelopePath).absolutePath);
+        const hasAttachmentManifest = await pathExists(resolveVaultPath(vaultRoot, attachmentManifestPath).absolutePath);
+        if (!hasEnvelope && !hasAttachmentManifest) {
+            issues.push(validationIssue("RAW_REFERENCE_MISSING", `Inbox capture directory "${captureDirectory}" is missing envelope.json and has no attachment recovery manifest.`, envelopePath));
+        }
+    }
+    for (const directory of [...artifactDirectories].sort()) {
+        const manifestPath = path.posix.join(directory, "manifest.json");
+        if (!(await pathExists(resolveVaultPath(vaultRoot, manifestPath).absolutePath))) {
+            issues.push(validationIssue("RAW_MANIFEST_INVALID", `Raw import directory "${directory}" is missing manifest.json.`, manifestPath));
+        }
+    }
+    for (const manifestPath of manifestFiles.sort()) {
+        issues.push(...(await validateRawManifestFile(vaultRoot, manifestPath)));
+    }
+    for (const manifestPath of [...inboxAttachmentManifestFiles].sort()) {
+        issues.push(...(await validateRawManifestFile(vaultRoot, manifestPath)));
+    }
+    return issues;
+}
+async function validateCurrentProfileConsistency(vaultRoot) {
+    let snapshots;
+    try {
+        snapshots = await listProfileSnapshots({ vaultRoot });
+    }
+    catch {
+        return [];
+    }
+    const latestSnapshot = snapshots.at(-1) ?? null;
+    const currentProfilePath = resolveVaultPath(vaultRoot, VAULT_LAYOUT.profileCurrentDocument);
+    const exists = await pathExists(currentProfilePath.absolutePath);
+    if (!latestSnapshot) {
+        return exists
+            ? [
+                validationIssue("PROFILE_CURRENT_STALE", "Current profile exists even though no profile snapshots are present.", VAULT_LAYOUT.profileCurrentDocument),
+            ]
+            : [];
+    }
+    if (!exists) {
+        return [
+            validationIssue("PROFILE_CURRENT_STALE", "Current profile is missing for the latest profile snapshot.", VAULT_LAYOUT.profileCurrentDocument),
+        ];
+    }
+    try {
+        const currentMarkdown = await readUtf8File(vaultRoot, VAULT_LAYOUT.profileCurrentDocument);
+        const expectedMarkdown = buildCurrentProfileMarkdown(latestSnapshot);
+        if (currentMarkdown !== expectedMarkdown) {
+            return [
+                validationIssue("PROFILE_CURRENT_STALE", "Current profile markdown does not match the latest profile snapshot.", VAULT_LAYOUT.profileCurrentDocument),
+            ];
+        }
+    }
+    catch (error) {
+        return [
+            validationIssue(error instanceof VaultError ? error.code : "PROFILE_CURRENT_STALE", error instanceof Error ? error.message : String(error), VAULT_LAYOUT.profileCurrentDocument),
+        ];
+    }
+    return [];
+}
+async function validateWriteOperations(vaultRoot) {
+    const operationPaths = await listWriteOperationMetadataPaths(vaultRoot);
+    const issues = [];
+    for (const relativePath of operationPaths.sort()) {
+        try {
+            const operation = await readStoredWriteOperation(vaultRoot, relativePath);
+            if (isTerminalWriteOperationStatus(operation.status)) {
+                continue;
+            }
+            const errorSuffix = operation.error?.message ? ` Last error: ${operation.error.message}` : "";
+            issues.push(validationIssue("OPERATION_UNRESOLVED", `Write operation "${operation.operationId}" is ${operation.status}.${errorSuffix}`, relativePath));
+        }
+        catch (error) {
+            issues.push(validationIssue(error instanceof VaultError ? error.code : "OPERATION_INVALID", error instanceof Error ? error.message : String(error), relativePath));
+        }
+    }
+    return issues;
+}
+export async function validateVault({ vaultRoot } = {}) {
+    const absoluteRoot = normalizeVaultRoot(vaultRoot);
+    const issues = [];
+    let metadata = null;
+    try {
+        const loadedVault = await loadVaultMetadata(absoluteRoot, "VAULT_INVALID_METADATA", "Vault metadata failed contract validation.");
+        metadata = loadedVault.metadata;
+    }
+    catch (error) {
+        issues.push(validationIssue(error instanceof VaultError ? error.code : "VAULT_LOAD_FAILED", error instanceof Error ? error.message : String(error), VAULT_LAYOUT.metadata));
+        return {
+            valid: false,
+            issues,
+            metadata,
+        };
+    }
+    for (const relativeDirectory of REQUIRED_DIRECTORIES) {
+        const directoryPath = resolveVaultPath(absoluteRoot, relativeDirectory);
+        if (!(await pathExists(directoryPath.absolutePath))) {
+            issues.push(validationIssue("VAULT_MISSING_DIRECTORY", `Missing required directory "${relativeDirectory}".`, relativeDirectory));
+        }
+    }
+    issues.push(...(await validateFrontmatterFile({
+        vaultRoot: absoluteRoot,
+        relativePath: VAULT_LAYOUT.coreDocument,
+        schema: coreFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    const experimentFiles = await walkVaultFiles(absoluteRoot, VAULT_LAYOUT.experimentsDirectory, {
+        extension: ".md",
+    });
+    for (const relativePath of experimentFiles) {
+        issues.push(...(await validateFrontmatterFile({
+            vaultRoot: absoluteRoot,
+            relativePath,
+            schema: experimentFrontmatterSchema,
+            code: "FRONTMATTER_INVALID",
+        })));
+    }
+    const journalFiles = await walkVaultFiles(absoluteRoot, VAULT_LAYOUT.journalDirectory, {
+        extension: ".md",
+    });
+    for (const relativePath of journalFiles) {
+        issues.push(...(await validateFrontmatterFile({
+            vaultRoot: absoluteRoot,
+            relativePath,
+            schema: journalDayFrontmatterSchema,
+            code: "FRONTMATTER_INVALID",
+        })));
+    }
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.goalsDirectory,
+        schema: goalFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.conditionsDirectory,
+        schema: conditionFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.allergiesDirectory,
+        schema: allergyFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.protocolsDirectory,
+        schema: protocolFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.foodsDirectory,
+        schema: foodFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.recipesDirectory,
+        schema: recipeFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.workoutFormatsDirectory,
+        schema: workoutFormatFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.familyDirectory,
+        schema: familyMemberFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    issues.push(...(await validateFrontmatterDirectory({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.geneticsDirectory,
+        schema: geneticVariantFrontmatterSchema,
+        code: "FRONTMATTER_INVALID",
+    })));
+    const currentProfilePath = resolveVaultPath(absoluteRoot, VAULT_LAYOUT.profileCurrentDocument);
+    if (await pathExists(currentProfilePath.absolutePath)) {
+        issues.push(...(await validateFrontmatterFile({
+            vaultRoot: absoluteRoot,
+            relativePath: VAULT_LAYOUT.profileCurrentDocument,
+            schema: profileCurrentFrontmatterSchema,
+            code: "FRONTMATTER_INVALID",
+        })));
+    }
+    issues.push(...(await validateJsonlFamily({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.assessmentLedgerDirectory,
+        schema: assessmentResponseSchema,
+        code: "CONTRACT_INVALID",
+        postValidateRecord: async (record) => validateAssessmentRecordReferences(absoluteRoot, record),
+    })));
+    issues.push(...(await validateJsonlFamily({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.eventLedgerDirectory,
+        schema: eventRecordSchema,
+        code: "EVENT_INVALID",
+        postValidateRecord: async (record) => validateEventRecordReferences(absoluteRoot, record),
+    })));
+    issues.push(...(await validateJsonlFamily({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.profileSnapshotsDirectory,
+        schema: profileSnapshotSchema,
+        code: "CONTRACT_INVALID",
+    })));
+    issues.push(...(await validateJsonlFamily({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.sampleLedgerDirectory,
+        schema: sampleRecordSchema,
+        code: "SAMPLE_INVALID",
+    })));
+    issues.push(...(await validateJsonlFamily({
+        vaultRoot: absoluteRoot,
+        relativeDirectory: VAULT_LAYOUT.auditDirectory,
+        schema: auditRecordSchema,
+        code: "AUDIT_INVALID",
+    })));
+    issues.push(...(await validateRawImportManifests(absoluteRoot)));
+    issues.push(...(await validateCurrentProfileConsistency(absoluteRoot)));
+    issues.push(...(await validateWriteOperations(absoluteRoot)));
+    return {
+        valid: issues.every((issue) => issue.severity !== "error"),
+        issues,
+        metadata,
+    };
+}
+//# sourceMappingURL=vault.js.map