@murphai/murph 1.3.1 → 1.3.2

package/dist/commands/scheduled-log.js

@@ -1,5 +1,5 @@
 import { Cli, z } from "incur";
-import { NUTRITION_CONFIDENCE_LEVELS, NUTRITION_PROVENANCE_SOURCES, executableScheduleIntentSchema, formatScheduleIntentIssues, scheduleIntentKindValues, scheduledLogActionSchema, scheduledLogScaffoldPayloadSchema, scheduledLogStatusValues, workoutSessionSchema, } from "@murphai/contracts";
+import { NUTRITION_CONFIDENCE_LEVELS, NUTRITION_PROVENANCE_SOURCES, executableScheduleIntentSchema, formatScheduleIntentIssues, scheduleIntentKindValues, scheduledLogActionSchema, scheduledLogScaffoldPayloadSchema, scheduledLogStatusValues, } from "@murphai/contracts";
 import { buildScheduledLogMarkdownPreview, scaffoldScheduledLogPayload, setScheduledLogStatus, upsertScheduledLog, } from "@murphai/core";
 import { listScheduledLogs, showScheduledLog, } from "@murphai/query";
 import { withBaseOptions } from "@murphai/operator-config/command-helpers";
@@ -7,6 +7,8 @@ import { VaultCliError } from "@murphai/operator-config/vault-cli-errors";
 import { isoTimestampSchema, pathSchema, } from "@murphai/operator-config/vault-cli-contracts";
 import { loadJsonInputObject, normalizeRepeatableFlagOption, normalizeRepeatableTextFlagOption, textInputOptionSchema, } from "@murphai/vault-usecases";
 import { compactNumber, parseCompactFields, rejectUnsupportedCompactFields, requireCompactInteger, requireCompactString, } from "./compact-field-spec.js";
+import { publicValidationIssue } from "./public-validation-issue.js";
+import { buildWorkoutFromParsedOptions, } from "./workout-typed-options.js";
 const scheduledLogSlugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const scheduledLogActionKindValues = [
     "meal.add",
@@ -92,18 +94,24 @@ function toScheduledLogListItem(record) {
         actionKind: record.action.kind,
     };
 }
-function invalidScheduledLogOption(message) {
-    throw new VaultCliError("invalid_option", message);
+function invalidScheduledLogOption(message, paths) {
+    throw new VaultCliError("invalid_option", message, {
+        issues: paths.map((path) => publicValidationIssue({ code: "custom" }, [path])),
+        stage: "validation",
+    });
+}
+function invalidScheduledLogOptionFor(path) {
+    return (message) => invalidScheduledLogOption(message, [path]);
 }
-function requireStringOption(value, optionName) {
+function requireStringOption(value, optionName, path) {
     if (typeof value === "string" && value.length > 0)
         return value;
-    return invalidScheduledLogOption(`--${optionName} is required for this scheduled-log save mode.`);
+    return invalidScheduledLogOption(`--${optionName} is required for this scheduled-log save mode.`, [path]);
 }
-function requireNumberOption(value, optionName) {
+function requireNumberOption(value, optionName, path) {
     if (typeof value === "number" && Number.isFinite(value))
         return value;
-    return invalidScheduledLogOption(`--${optionName} is required for this scheduled-log save mode.`);
+    return invalidScheduledLogOption(`--${optionName} is required for this scheduled-log save mode.`, [path]);
 }
 function parseQualifierValue(rawValue) {
     const trimmed = rawValue.trim();
@@ -134,7 +142,7 @@ function parseMeasurementNoteEntries(value, measurementCount) {
             oneBasedIndex < 1 ||
             oneBasedIndex > measurementCount ||
             note.length === 0) {
-            invalidScheduledLogOption("Each --measurement-note entry must use N:note form when multiple measurements are provided.");
+            invalidScheduledLogOption("Each --measurement-note entry must use N:note form when multiple measurements are provided.", ["measurementNote"]);
         }
         notes.set(oneBasedIndex - 1, note);
     }
@@ -161,11 +169,11 @@ function parseMeasurementQualifierEntries(value, measurementCount) {
             pairSeparatorIndex === pair.length - 1 ||
             key.length === 0 ||
             rawValue.length === 0) {
-            invalidScheduledLogOption("Each --measurement-qualifier entry must use key=value form for one measurement or N:key=value form for multiple measurements.");
+            invalidScheduledLogOption("Each --measurement-qualifier entry must use key=value form for one measurement or N:key=value form for multiple measurements.", ["measurementQualifier"]);
         }
         const targetQualifiers = qualifiers[targetIndex];
         if (!targetQualifiers) {
-            invalidScheduledLogOption("Each --measurement-qualifier entry must use key=value form for one measurement or N:key=value form for multiple measurements.");
+            invalidScheduledLogOption("Each --measurement-qualifier entry must use key=value form for one measurement or N:key=value form for multiple measurements.", ["measurementQualifier"]);
         }
         targetQualifiers[key] = parseQualifierValue(rawValue);
     }
@@ -176,31 +184,34 @@ function buildScheduleIntentFromOptions(options) {
         case "at":
             return parseScheduledLogScheduleIntent({
                 kind: "at",
-                at: requireStringOption(options.scheduleAt, "schedule-at"),
-            });
+                at: requireStringOption(options.scheduleAt, "schedule-at", "scheduleAt"),
+            }, "scheduleAt");
         case "every":
             return parseScheduledLogScheduleIntent({
                 kind: "every",
-                everyMs: requireNumberOption(options.scheduleEveryMs, "schedule-every-ms"),
-            });
+                everyMs: requireNumberOption(options.scheduleEveryMs, "schedule-every-ms", "scheduleEveryMs"),
+            }, "scheduleEveryMs");
         case "cron":
             return parseScheduledLogScheduleIntent({
                 kind: "cron",
-                expression: requireStringOption(options.scheduleCron, "schedule-cron"),
-            });
+                expression: requireStringOption(options.scheduleCron, "schedule-cron", "scheduleCron"),
+            }, "scheduleCron");
         case "dailyLocal":
             return parseScheduledLogScheduleIntent({
                 kind: "dailyLocal",
-                localTime: requireStringOption(options.scheduleLocalTime, "schedule-local-time"),
-            });
+                localTime: requireStringOption(options.scheduleLocalTime, "schedule-local-time", "scheduleLocalTime"),
+            }, "scheduleLocalTime");
     }
 }
-function parseScheduledLogScheduleIntent(value) {
+function parseScheduledLogScheduleIntent(value, path) {
     const parsed = executableScheduleIntentSchema.safeParse(value);
     if (!parsed.success) {
         const message = formatScheduleIntentIssues(parsed.error) ||
             "schedule must match a supported scheduled-log schedule.";
-        invalidScheduledLogOption(message);
+        throw new VaultCliError("invalid_option", message, {
+            issues: parsed.error.issues.map((issue) => publicValidationIssue(issue, [path])),
+            stage: "validation",
+        });
     }
     return parsed.data;
 }
@@ -223,7 +234,7 @@ function buildMealNutritionFromOptions(options) {
     if (!hasTotals && !hasProvenance)
         return undefined;
     if (hasProvenance && options.nutritionSource === undefined) {
-        invalidScheduledLogOption("--nutrition-source is required when nutrition provenance fields are provided.");
+        invalidScheduledLogOption("--nutrition-source is required when nutrition provenance fields are provided.", ["nutritionSource"]);
     }
     const nutrition = {};
     if (hasTotals)
@@ -243,10 +254,10 @@ function buildMeasurementsFromOptions(options) {
     const values = options.measurementValue;
     const count = metrics?.length ?? 0;
     if (!metrics || !units || !values || count === 0) {
-        invalidScheduledLogOption("measurement.add scheduled logs require repeated --measurement-metric, --measurement-value, and --measurement-unit fields.");
+        invalidScheduledLogOption("measurement.add scheduled logs require repeated --measurement-metric, --measurement-value, and --measurement-unit fields.", ["measurementMetric", "measurementValue", "measurementUnit"]);
     }
     if (values.length !== count || units.length !== count) {
-        invalidScheduledLogOption("Repeated --measurement-metric, --measurement-value, and --measurement-unit fields must have the same count.");
+        invalidScheduledLogOption("Repeated --measurement-metric, --measurement-value, and --measurement-unit fields must have the same count.", ["measurementMetric", "measurementValue", "measurementUnit"]);
     }
     const notes = parseMeasurementNoteEntries(options.measurementNote, count);
     const qualifiers = parseMeasurementQualifierEntries(options.measurementQualifier, count);
@@ -274,13 +285,13 @@ const workoutOptionKeys = [
     "workoutExercise",
     "workoutSet",
 ];
-const workoutMediaFieldKeys = [
+const workoutMediaFieldKeys = new Set([
     "kind",
     "relativePath",
     "mediaType",
     "caption",
-];
-const workoutExerciseFieldKeys = [
+]);
+const workoutExerciseFieldKeys = new Set([
     "order",
     "name",
     "sourceExerciseId",
@@ -288,8 +299,8 @@ const workoutExerciseFieldKeys = [
     "mode",
     "unitOverride",
     "note",
-];
-const workoutSetFieldKeys = [
+]);
+const workoutSetFieldKeys = new Set([
     "exercise",
     "order",
     "type",
@@ -302,23 +313,31 @@ const workoutSetFieldKeys = [
     "bodyweightKg",
     "assistanceKg",
     "addedWeightKg",
-];
+]);
+const workoutPublicFields = {
+    media: workoutMediaFieldKeys,
+    exercise: workoutExerciseFieldKeys,
+    set: workoutSetFieldKeys,
+};
+const invalidWorkoutMediaOption = invalidScheduledLogOptionFor("workoutMedia");
+const invalidWorkoutExerciseOption = invalidScheduledLogOptionFor("workoutExercise");
+const invalidWorkoutSetOption = invalidScheduledLogOptionFor("workoutSet");
 function parseWorkoutMediaEntry(entry) {
-    const fields = parseCompactFields(entry, "workout-media", invalidScheduledLogOption);
-    rejectUnsupportedCompactFields(fields, "workout-media", workoutMediaFieldKeys, invalidScheduledLogOption);
+    const fields = parseCompactFields(entry, "workout-media", invalidWorkoutMediaOption);
+    rejectUnsupportedCompactFields(fields, "workout-media", workoutMediaFieldKeys, invalidWorkoutMediaOption);
     return {
-        kind: requireCompactString(fields, "kind", "workout-media", invalidScheduledLogOption),
-        relativePath: requireCompactString(fields, "relativePath", "workout-media", invalidScheduledLogOption),
+        kind: requireCompactString(fields, "kind", "workout-media", invalidWorkoutMediaOption),
+        relativePath: requireCompactString(fields, "relativePath", "workout-media", invalidWorkoutMediaOption),
         ...(fields.has("mediaType") ? { mediaType: fields.get("mediaType") } : {}),
         ...(fields.has("caption") ? { caption: fields.get("caption") } : {}),
     };
 }
 function parseWorkoutExerciseEntry(entry) {
-    const fields = parseCompactFields(entry, "workout-exercise", invalidScheduledLogOption);
-    rejectUnsupportedCompactFields(fields, "workout-exercise", workoutExerciseFieldKeys, invalidScheduledLogOption);
+    const fields = parseCompactFields(entry, "workout-exercise", invalidWorkoutExerciseOption);
+    rejectUnsupportedCompactFields(fields, "workout-exercise", workoutExerciseFieldKeys, invalidWorkoutExerciseOption);
     return {
-        name: requireCompactString(fields, "name", "workout-exercise", invalidScheduledLogOption),
-        order: requireCompactInteger(fields, "order", "workout-exercise", invalidScheduledLogOption),
+        name: requireCompactString(fields, "name", "workout-exercise", invalidWorkoutExerciseOption),
+        order: requireCompactInteger(fields, "order", "workout-exercise", invalidWorkoutExerciseOption),
         sets: [],
         ...(fields.has("sourceExerciseId")
             ? { sourceExerciseId: fields.get("sourceExerciseId") }
@@ -330,11 +349,11 @@ function parseWorkoutExerciseEntry(entry) {
     };
 }
 function parseWorkoutSetEntry(entry) {
-    const fields = parseCompactFields(entry, "workout-set", invalidScheduledLogOption);
-    rejectUnsupportedCompactFields(fields, "workout-set", workoutSetFieldKeys, invalidScheduledLogOption);
-    const exerciseOrder = requireCompactInteger(fields, "exercise", "workout-set", invalidScheduledLogOption);
+    const fields = parseCompactFields(entry, "workout-set", invalidWorkoutSetOption);
+    rejectUnsupportedCompactFields(fields, "workout-set", workoutSetFieldKeys, invalidWorkoutSetOption);
+    const exerciseOrder = requireCompactInteger(fields, "exercise", "workout-set", invalidWorkoutSetOption);
     const set = {
-        order: requireCompactInteger(fields, "order", "workout-set", invalidScheduledLogOption),
+        order: requireCompactInteger(fields, "order", "workout-set", invalidWorkoutSetOption),
     };
     for (const key of [
         "type",
@@ -354,7 +373,7 @@ function parseWorkoutSetEntry(entry) {
         "assistanceKg",
         "addedWeightKg",
     ]) {
-        const value = compactNumber(fields, key, "workout-set", invalidScheduledLogOption);
+        const value = compactNumber(fields, key, "workout-set", invalidWorkoutSetOption);
         if (value !== undefined) {
             set[key] = value;
         }
@@ -371,65 +390,396 @@ function buildWorkoutFromOptions(options) {
     if (!hasWorkoutOptions(options)) {
         return undefined;
     }
-    const workout = {
-        exercises: [],
-    };
-    if (options.workoutSourceApp !== undefined)
-        workout.sourceApp = options.workoutSourceApp;
-    if (options.workoutSourceWorkoutId !== undefined) {
-        workout.sourceWorkoutId = options.workoutSourceWorkoutId;
-    }
-    if (options.workoutStartedAt !== undefined)
-        workout.startedAt = options.workoutStartedAt;
-    if (options.workoutEndedAt !== undefined)
-        workout.endedAt = options.workoutEndedAt;
-    if (options.workoutRoutineId !== undefined)
-        workout.routineId = options.workoutRoutineId;
-    if (options.workoutRoutineName !== undefined)
-        workout.routineName = options.workoutRoutineName;
-    if (options.workoutSessionNote !== undefined)
-        workout.sessionNote = options.workoutSessionNote;
     const mediaEntries = normalizeRepeatableFlagOption(options.workoutMedia, "workout-media");
-    if (mediaEntries) {
-        workout.media = mediaEntries.map(parseWorkoutMediaEntry);
-    }
-    const exercisesByOrder = new Map();
     const exerciseEntries = normalizeRepeatableFlagOption(options.workoutExercise, "workout-exercise");
-    for (const exercise of exerciseEntries?.map(parseWorkoutExerciseEntry) ?? []) {
-        if (exercisesByOrder.has(exercise.order)) {
-            invalidScheduledLogOption(`Duplicate --workout-exercise order ${exercise.order}.`);
-        }
-        exercisesByOrder.set(exercise.order, exercise);
-    }
     const setEntries = normalizeRepeatableFlagOption(options.workoutSet, "workout-set");
-    for (const { exerciseOrder, set } of setEntries?.map(parseWorkoutSetEntry) ?? []) {
-        const exercise = exercisesByOrder.get(exerciseOrder);
-        if (!exercise) {
-            invalidScheduledLogOption(`--workout-set references exercise ${exerciseOrder}, but no matching --workout-exercise was provided.`);
-        }
-        exercise.sets.push(set);
+    return buildWorkoutFromParsedOptions({
+        scalarOptions: options,
+        media: mediaEntries?.map(parseWorkoutMediaEntry),
+        exercises: exerciseEntries?.map(parseWorkoutExerciseEntry),
+        sets: setEntries?.map(parseWorkoutSetEntry),
+        publicFields: workoutPublicFields,
+        validationMessage: "Invalid workout template fields.",
+        invalidExerciseOption: invalidWorkoutExerciseOption,
+        invalidSetOption: invalidWorkoutSetOption,
+    });
+}
+const mealActionOptionKeys = [
+    "foodId",
+    "ingredient",
+    "nutritionCalories",
+    "nutritionCarbsGrams",
+    "nutritionConfidence",
+    "nutritionFatGrams",
+    "nutritionFiberGrams",
+    "nutritionProteinGrams",
+    "nutritionSource",
+    "nutritionSourceDetail",
+];
+const activityActionOptionKeys = [
+    "actionTitle",
+    "activityType",
+    "distanceKm",
+    "durationMinutes",
+    ...workoutOptionKeys,
+];
+const interventionActionOptionKeys = [
+    "actionTitle",
+    "durationMinutes",
+    "interventionType",
+    "protocolId",
+];
+const measurementActionOptionKeys = [
+    "actionTitle",
+    "measurementMetric",
+    "measurementNote",
+    "measurementQualifier",
+    "measurementUnit",
+    "measurementValue",
+];
+export const scheduledLogActionOptionKeysByKind = {
+    "meal.add": mealActionOptionKeys,
+    "activity_session.add": activityActionOptionKeys,
+    "intervention_session.add": interventionActionOptionKeys,
+    "measurement.add": measurementActionOptionKeys,
+};
+const actionSpecificOptionKeys = [
+    ...scheduledLogActionOptionKeysByKind["meal.add"],
+    ...scheduledLogActionOptionKeysByKind["activity_session.add"],
+    ...scheduledLogActionOptionKeysByKind["intervention_session.add"],
+    ...scheduledLogActionOptionKeysByKind["measurement.add"],
+];
+const allowedActionOptionKeys = {
+    "meal.add": new Set(scheduledLogActionOptionKeysByKind["meal.add"]),
+    "activity_session.add": new Set(scheduledLogActionOptionKeysByKind["activity_session.add"]),
+    "intervention_session.add": new Set(scheduledLogActionOptionKeysByKind["intervention_session.add"]),
+    "measurement.add": new Set(scheduledLogActionOptionKeysByKind["measurement.add"]),
+};
+function rejectIncompatibleScheduledLogActionOptions(options) {
+    const allowed = allowedActionOptionKeys[options.actionKind];
+    const incompatible = [...new Set(actionSpecificOptionKeys)].filter((key) => options[key] !== undefined && !allowed.has(key));
+    if (incompatible.length === 0) {
+        return;
+    }
+    throw new VaultCliError("invalid_option", "Some action fields are incompatible with the selected scheduled-log action kind.", {
+        issues: incompatible.map((key) => publicValidationIssue({ code: "custom" }, [key])),
+        stage: "validation",
+    });
+}
+function typedActionIssueOptionPath(path) {
+    switch (path[0]) {
+        case "foodId":
+            return "foodId";
+        case "ingredients":
+            return "ingredient";
+        case "note":
+            return "actionNote";
+        case "tags":
+            return "actionTag";
+        case "title":
+            return "actionTitle";
+        case "activityType":
+            return "activityType";
+        case "durationMinutes":
+            return "durationMinutes";
+        case "distanceKm":
+            return "distanceKm";
+        case "interventionType":
+            return "interventionType";
+        case "protocolId":
+            return "protocolId";
+        case "measurements":
+            if (path.includes("qualifiers")) {
+                return "measurementQualifier";
+            }
+            switch (path.at(-1)) {
+                case "value":
+                    return "measurementValue";
+                case "unit":
+                    return "measurementUnit";
+                case "note":
+                    return "measurementNote";
+                default:
+                    return "measurementMetric";
+            }
+        case "workout":
+            return path.includes("sets") ? "workoutSet" : "workoutExercise";
+        case "nutrition":
+            switch (path.at(-1)) {
+                case "calories":
+                    return "nutritionCalories";
+                case "proteinGrams":
+                    return "nutritionProteinGrams";
+                case "carbsGrams":
+                    return "nutritionCarbsGrams";
+                case "fatGrams":
+                    return "nutritionFatGrams";
+                case "fiberGrams":
+                    return "nutritionFiberGrams";
+                case "source":
+                    return "nutritionSource";
+                case "confidence":
+                    return "nutritionConfidence";
+                case "sourceDetail":
+                    return "nutritionSourceDetail";
+                default:
+                    return "nutritionSource";
+            }
+        default:
+            return "actionKind";
     }
-    workout.exercises = [...exercisesByOrder.values()].sort((left, right) => left.order - right.order);
-    const parsed = workoutSessionSchema.safeParse(workout);
+}
+function parseScheduledLogAction(value) {
+    const parsed = scheduledLogActionSchema.safeParse(value);
     if (!parsed.success) {
-        throw new VaultCliError("invalid_option", "Invalid workout template fields.", {
-            issues: parsed.error.issues,
+        throw new VaultCliError("invalid_option", "Invalid scheduled-log action fields.", {
+            issues: parsed.error.issues.map((issue) => publicValidationIssue(issue, [typedActionIssueOptionPath(issue.path)])),
+            stage: "validation",
+        });
+    }
+    return parsed.data;
+}
+function parseScheduledLogPayload(value, code, surface) {
+    const parsed = scheduledLogScaffoldPayloadSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new VaultCliError(code, "Invalid scheduled-log payload fields.", {
+            issues: parsed.error.issues.flatMap((issue) => {
+                const publicPath = scheduledLogPayloadIssuePath(issue.path, surface);
+                return publicPath === undefined
+                    ? []
+                    : [publicValidationIssue(issue, publicPath)];
+            }),
+            stage: "validation",
         });
     }
     return parsed.data;
 }
+function scheduledLogPayloadIssuePath(path, surface) {
+    if (surface === "import_json") {
+        if (path[0] === "action" &&
+            path[1] === "measurements" &&
+            typeof path[2] === "number" &&
+            path[3] === "qualifiers") {
+            return ["action", "measurements", path[2], "qualifiers"];
+        }
+        return scheduledLogImportIssuePath(path);
+    }
+    switch (path[0]) {
+        case "scheduledLogId":
+            return ["id"];
+        case "tags":
+            return ["tag"];
+        case "action":
+            return [typedActionIssueOptionPath(path.slice(1))];
+        case "schedule":
+            switch (path[1]) {
+                case "at":
+                    return ["scheduleAt"];
+                case "everyMs":
+                    return ["scheduleEveryMs"];
+                case "expression":
+                    return ["scheduleCron"];
+                case "localTime":
+                    return ["scheduleLocalTime"];
+                default:
+                    return ["scheduleKind"];
+            }
+        case "slug":
+        case "title":
+        case "status":
+        case "summary":
+        case "body":
+            return [path[0]];
+        default:
+            return undefined;
+    }
+}
+const scheduledLogImportPublicPathSegments = new Set([
+    "scheduledLogId",
+    "slug",
+    "title",
+    "status",
+    "summary",
+    "schedule",
+    "action",
+    "tags",
+    "body",
+    "kind",
+    "at",
+    "everyMs",
+    "expression",
+    "localTime",
+    "foodId",
+    "note",
+    "ingredients",
+    "nutrition",
+    "totals",
+    "provenance",
+    "calories",
+    "proteinGrams",
+    "carbsGrams",
+    "fatGrams",
+    "fiberGrams",
+    "source",
+    "confidence",
+    "sourceDetail",
+    "activityType",
+    "durationMinutes",
+    "distanceKm",
+    "workout",
+    "interventionType",
+    "protocolId",
+    "measurements",
+    "metric",
+    "value",
+    "unit",
+    "qualifiers",
+    "sourceApp",
+    "sourceWorkoutId",
+    "startedAt",
+    "endedAt",
+    "routineId",
+    "routineName",
+    "sessionNote",
+    "media",
+    "exercises",
+    "sets",
+    "order",
+    "name",
+    "sourceExerciseId",
+    "groupId",
+    "mode",
+    "unitOverride",
+    "type",
+    "reps",
+    "weight",
+    "weightUnit",
+    "durationSeconds",
+    "distanceMeters",
+    "rpe",
+    "bodyweightKg",
+    "assistanceKg",
+    "addedWeightKg",
+    "relativePath",
+    "mediaType",
+    "caption",
+]);
+function scheduledLogImportIssuePath(path) {
+    if (path.length === 0)
+        return undefined;
+    const publicPath = [];
+    for (const segment of path) {
+        if (typeof segment === "number" && Number.isSafeInteger(segment) && segment >= 0) {
+            publicPath.push(segment);
+            continue;
+        }
+        if (typeof segment === "string" && scheduledLogImportPublicPathSegments.has(segment)) {
+            publicPath.push(segment);
+            continue;
+        }
+        return undefined;
+    }
+    return publicPath;
+}
+function isScheduledLogVaultError(error) {
+    return Boolean(error instanceof Error &&
+        error.name === "VaultError" &&
+        "code" in error &&
+        typeof error.code === "string");
+}
+function readScheduledLogValidationIssues(error) {
+    if (!error.details ||
+        typeof error.details !== "object" ||
+        !("issues" in error.details) ||
+        !Array.isArray(error.details.issues)) {
+        return [];
+    }
+    return error.details.issues.flatMap((issue) => {
+        if (!issue ||
+            typeof issue !== "object" ||
+            !("path" in issue) ||
+            !Array.isArray(issue.path) ||
+            !("code" in issue) ||
+            typeof issue.code !== "string") {
+            return [];
+        }
+        return [{
+                path: issue.path,
+                code: issue.code,
+            }];
+    });
+}
+function storedScheduledLogFailureMessage(issues) {
+    const recovery = "Stop without retrying or writing scheduled logs and report that operator repair is required.";
+    const issue = issues[0];
+    if (!issue) {
+        return `Stored scheduled-log registry data is invalid. ${recovery}`;
+    }
+    const publicPath = scheduledLogImportIssuePath(issue.path);
+    const code = /^[a-z][a-z0-9_]{0,63}$/u.test(issue.code)
+        ? issue.code
+        : "invalid_value";
+    const location = publicPath === undefined
+        ? `code ${code}`
+        : `path ${publicPath.join(".")}, code ${code}`;
+    return `Stored scheduled-log registry data is invalid (${location}). ${recovery}`;
+}
+function toScheduledLogCliError(error, options = {}) {
+    if (error instanceof VaultCliError || !isScheduledLogVaultError(error)) {
+        return error;
+    }
+    switch (error.code) {
+        case "VAULT_SCHEDULED_LOG_MISSING":
+            return new VaultCliError("not_found", "The requested scheduled log was not found; list scheduled logs and retry with an existing id or slug.");
+        case "VAULT_SCHEDULED_LOG_CONFLICT":
+            return new VaultCliError("conflict", "The scheduled-log id and slug resolve to different records; retry with identifiers from the same record.");
+        case "VAULT_INVALID_SCHEDULED_LOG": {
+            const issues = readScheduledLogValidationIssues(error);
+            return new VaultCliError("invalid_registry", storedScheduledLogFailureMessage(issues), {
+                hint: "Stop without retrying or writing scheduled logs and report that operator repair is required.",
+                stage: "read",
+            });
+        }
+        case "VAULT_INVALID_INPUT": {
+            const issues = readScheduledLogValidationIssues(error);
+            const inputSurface = options.inputSurface;
+            if (inputSurface) {
+                return new VaultCliError(inputSurface === "typed_save" ? "invalid_option" : "invalid_payload", "Invalid scheduled-log payload fields.", issues.length > 0
+                    ? {
+                        issues: issues.flatMap((issue) => {
+                            const publicPath = scheduledLogPayloadIssuePath(issue.path, inputSurface);
+                            return publicPath === undefined
+                                ? []
+                                : [publicValidationIssue(issue, publicPath)];
+                        }),
+                        stage: "validation",
+                    }
+                    : { stage: "validation" });
+            }
+            return new VaultCliError("contract_invalid", "Scheduled-log data failed canonical validation; correct the submitted inputs before retrying.");
+        }
+        default:
+            return error;
+    }
+}
+async function runScheduledLogOperation(operation, options = {}) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        throw toScheduledLogCliError(error, options);
+    }
+}
 function buildScheduledLogActionFromOptions(options) {
+    rejectIncompatibleScheduledLogActionOptions(options);
     const actionTags = normalizeRepeatableFlagOption(options.actionTag, "action-tag");
     const commonFields = actionTags ? { tags: actionTags } : {};
     const workout = buildWorkoutFromOptions(options);
-    if (workout && options.actionKind !== "activity_session.add") {
-        invalidScheduledLogOption("Workout template fields are only valid with --action-kind=activity_session.add.");
-    }
     switch (options.actionKind) {
         case "meal.add": {
             const ingredients = normalizeRepeatableFlagOption(options.ingredient, "ingredient");
             const nutrition = buildMealNutritionFromOptions(options);
-            return scheduledLogActionSchema.parse({
+            return parseScheduledLogAction({
                 kind: "meal.add",
                 ...commonFields,
                 ...(options.foodId ? { foodId: options.foodId } : {}),
@@ -439,22 +789,22 @@ function buildScheduledLogActionFromOptions(options) {
             });
         }
         case "activity_session.add":
-            return scheduledLogActionSchema.parse({
+            return parseScheduledLogAction({
                 kind: "activity_session.add",
                 ...commonFields,
-                title: requireStringOption(options.actionTitle, "action-title"),
-                activityType: requireStringOption(options.activityType, "activity-type"),
-                durationMinutes: requireNumberOption(options.durationMinutes, "duration-minutes"),
+                title: requireStringOption(options.actionTitle, "action-title", "actionTitle"),
+                activityType: requireStringOption(options.activityType, "activity-type", "activityType"),
+                durationMinutes: requireNumberOption(options.durationMinutes, "duration-minutes", "durationMinutes"),
                 ...(options.distanceKm !== undefined ? { distanceKm: options.distanceKm } : {}),
                 ...(options.actionNote ? { note: options.actionNote } : {}),
                 ...(workout ? { workout } : {}),
             });
         case "intervention_session.add":
-            return scheduledLogActionSchema.parse({
+            return parseScheduledLogAction({
                 kind: "intervention_session.add",
                 ...commonFields,
-                title: requireStringOption(options.actionTitle, "action-title"),
-                interventionType: requireStringOption(options.interventionType, "intervention-type"),
+                title: requireStringOption(options.actionTitle, "action-title", "actionTitle"),
+                interventionType: requireStringOption(options.interventionType, "intervention-type", "interventionType"),
                 ...(options.durationMinutes !== undefined
                     ? { durationMinutes: options.durationMinutes }
                     : {}),
@@ -462,7 +812,7 @@ function buildScheduledLogActionFromOptions(options) {
                 ...(options.actionNote ? { note: options.actionNote } : {}),
             });
         case "measurement.add":
-            return scheduledLogActionSchema.parse({
+            return parseScheduledLogAction({
                 kind: "measurement.add",
                 ...commonFields,
                 ...(options.actionTitle ? { title: options.actionTitle } : {}),
@@ -742,7 +1092,7 @@ export function registerScheduledLogCommands(cli) {
         }),
         output: scheduledLogWriteResultSchema,
         async run(context) {
-            const input = scheduledLogScaffoldPayloadSchema.parse({
+            const input = parseScheduledLogPayload({
                 scheduledLogId: context.options.id,
                 slug: context.options.slug,
                 title: context.args.title,
@@ -752,11 +1102,11 @@ export function registerScheduledLogCommands(cli) {
                 summary: context.options.summary,
                 tags: normalizeRepeatableFlagOption(context.options.tag, "tag"),
                 body: context.options.body ?? defaultScheduledLogBody(context.args.title, context.options.summary),
-            });
-            const result = await upsertScheduledLog({
+            }, "invalid_option", "typed_save");
+            const result = await runScheduledLogOperation(() => upsertScheduledLog({
                 ...input,
                 vaultRoot: context.options.vault,
-            });
+            }), { inputSurface: "typed_save" });
             return {
                 vault: context.options.vault,
                 scheduledLogId: result.record.scheduledLogId,
@@ -776,7 +1126,7 @@ export function registerScheduledLogCommands(cli) {
         async run(context) {
             return {
                 vault: context.options.vault,
-                scheduledLog: await showScheduledLog(context.options.vault, context.args.lookup),
+                scheduledLog: await runScheduledLogOperation(() => showScheduledLog(context.options.vault, context.args.lookup)),
             };
         },
     });
@@ -797,11 +1147,11 @@ export function registerScheduledLogCommands(cli) {
         }),
         output: scheduledLogListResultSchema,
         async run(context) {
-            const items = await listScheduledLogs(context.options.vault, {
+            const items = await runScheduledLogOperation(() => listScheduledLogs(context.options.vault, {
                 limit: context.options.limit,
                 status: context.options.status,
                 text: context.options.text,
-            });
+            }));
             return {
                 vault: context.options.vault,
                 filters: {
@@ -824,11 +1174,11 @@ export function registerScheduledLogCommands(cli) {
         output: scheduledLogWriteResultSchema,
         async run(context) {
             const rawInput = await loadJsonInputObject(context.options.input, "scheduled-log payload");
-            const input = scheduledLogScaffoldPayloadSchema.parse(rawInput);
-            const result = await upsertScheduledLog({
+            const input = parseScheduledLogPayload(rawInput, "invalid_payload", "import_json");
+            const result = await runScheduledLogOperation(() => upsertScheduledLog({
                 ...input,
                 vaultRoot: context.options.vault,
-            });
+            }), { inputSurface: "import_json" });
             return {
                 vault: context.options.vault,
                 scheduledLogId: result.record.scheduledLogId,
@@ -851,15 +1201,15 @@ export function registerScheduledLogCommands(cli) {
             options: withBaseOptions(),
             output: scheduledLogStatusResultSchema,
             async run(context) {
-                const existing = await showScheduledLog(context.options.vault, context.args.lookup);
+                const existing = await runScheduledLogOperation(() => showScheduledLog(context.options.vault, context.args.lookup));
                 if (!existing) {
-                    throw new Error(`Scheduled log "${context.args.lookup}" was not found.`);
+                    throw new VaultCliError("not_found", "The requested scheduled log was not found; list scheduled logs and retry with an existing id or slug.");
                 }
-                const result = await setScheduledLogStatus({
+                const result = await runScheduledLogOperation(() => setScheduledLogStatus({
                     vaultRoot: context.options.vault,
                     scheduledLogId: existing.scheduledLogId,
                     status,
-                });
+                }));
                 return {
                     vault: context.options.vault,
                     scheduledLogId: result.record.scheduledLogId,