@murphai/murph 1.3.1 → 1.3.2

package/node_modules/@murphai/vault-usecases/dist/usecases/workout-live.d.ts

@@ -1,5 +1,5 @@
-import { type WorkoutSessionDetailV1 } from '@murphai/contracts';
-import { type ApplyLiveWorkoutMemberActionInput, type ApplyLiveWorkoutMemberActionResult, type AddLiveWorkoutExerciseInput, type ClearLiveWorkoutSetInput, type FinishLiveWorkoutInput, type LiveWorkoutLookupInput, type LogLiveWorkoutSetInput, type StartLiveWorkoutInput } from './workout-live-model.js';
+import { type WorkoutLiveSnapshotMemberActionResultV1, type WorkoutLiveSnapshotMemberActionV1, type WorkoutSessionDetailV1 } from '@murphai/contracts';
+import { type ApplyLiveWorkoutMemberActionInput, type ApplyLiveWorkoutMemberActionResult, type AddLiveWorkoutExerciseInput, type ClearLiveWorkoutSetInput, type FinishLiveWorkoutInput, type LogLiveWorkoutSetInput, type SetLiveWorkoutExerciseRepsInput, type StartLiveWorkoutInput } from './workout-live-model.js';
 export * from './workout-live-model.js';
 export declare function readLiveWorkoutCardEditor(input: {
     presentation: WorkoutSessionDetailV1;
@@ -9,6 +9,16 @@ export declare function readLiveWorkoutCardEditor(input: {
     editor: import("@murphai/contracts").WorkoutSessionEditorProjectionV1;
     workout: WorkoutSessionDetailV1;
 } | null>;
+export declare function readLiveWorkoutCardSnapshot(input: {
+    action: WorkoutLiveSnapshotMemberActionV1;
+    vault: string;
+}): Promise<{
+    result: WorkoutLiveSnapshotMemberActionResultV1;
+    status: 'unchanged';
+} | {
+    reason: 'workout_changed';
+    status: 'rejected';
+}>;
 export declare function applyLiveWorkoutMemberAction(input: ApplyLiveWorkoutMemberActionInput): Promise<ApplyLiveWorkoutMemberActionResult>;
 export declare function startLiveWorkout(input: StartLiveWorkoutInput): Promise<{
     vault: string;
@@ -80,6 +90,8 @@ export declare function startLiveWorkout(input: StartLiveWorkoutInput): Promise<
             mode?: "assisted_bodyweight" | "bodyweight" | "cardio" | "duration" | "weight_reps" | "weighted_bodyweight" | undefined;
             unitOverride?: "kg" | "lb" | undefined;
             note?: string | undefined;
+            memberRepsPerSet?: number | undefined;
+            setPlanIsFinite?: boolean | undefined;
             sets: {
                 order: number;
                 type?: "dropset" | "failure" | "normal" | "warmup" | undefined;
@@ -99,11 +111,11 @@ export declare function startLiveWorkout(input: StartLiveWorkoutInput): Promise<
     manifestFile: string | null;
     note: string;
 }>;
-export declare function showActiveLiveWorkout(input: LiveWorkoutLookupInput): Promise<{
+export declare function addLiveWorkoutExercise(input: AddLiveWorkoutExerciseInput): Promise<{
     vault: string;
     entity: import("../helpers.ts").CommandShowEntity;
 }>;
-export declare function addLiveWorkoutExercise(input: AddLiveWorkoutExerciseInput): Promise<{
+export declare function setLiveWorkoutExerciseReps(input: SetLiveWorkoutExerciseRepsInput): Promise<{
     vault: string;
     entity: import("../helpers.ts").CommandShowEntity;
 }>;

package/node_modules/@murphai/vault-usecases/dist/usecases/workout-live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workout-live.d.ts","sourceRoot":"","sources":["../../src/usecases/workout-live.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,sBAAsB,EAM5B,MAAM,oBAAoB,CAAA;AAU3B,OAAO,EAEL,KAAK,iCAAiC,EACtC,KAAK,kCAAkC,EACvC,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAK3B,MAAM,yBAAyB,CAAA;AAqBhC,cAAc,yBAAyB,CAAA;AAEvC,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,YAAY,EAAE,sBAAsB,CAAA;IACpC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB;;;UAYA;AAKD,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,kCAAkC,CAAC,CAU7C;AA8WD,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIlE;AA2FD,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB;;;GAExE;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B;;;GAKnC;AA6DD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB;;;GAIpE;AA0DD,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB;;;GAIxE;AAiCD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB;;;GAIpE"}
+{"version":3,"file":"workout-live.d.ts","sourceRoot":"","sources":["../../src/usecases/workout-live.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,uCAAuC,EAC5C,KAAK,iCAAiC,EAMtC,KAAK,sBAAsB,EAQ5B,MAAM,oBAAoB,CAAA;AAc3B,OAAO,EAEL,KAAK,iCAAiC,EACtC,KAAK,kCAAkC,EACvC,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAE3B,KAAK,+BAA+B,EACpC,KAAK,qBAAqB,EAQ3B,MAAM,yBAAyB,CAAA;AAqBhC,cAAc,yBAAyB,CAAA;AAEvC,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,YAAY,EAAE,sBAAsB,CAAA;IACpC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB;;;UAYA;AAED,wBAAsB,2BAA2B,CAAC,KAAK,EAAE;IACvD,MAAM,EAAE,iCAAiC,CAAA;IACzC,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,OAAO,CACP;IACE,MAAM,EAAE,uCAAuC,CAAA;IAC/C,MAAM,EAAE,WAAW,CAAA;CACpB,GACD;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CACpD,CAsBA;AA+CD,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,kCAAkC,CAAC,CA+B7C;AAmhBD,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFlE;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B;;;GAMnC;AA+DD,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,+BAA+B;;;GAMvC;AAoDD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB;;;GAKpE;AAiGD,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB;;;GAKxE;AAkCD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB;;;GAIpE"}

package/node_modules/@murphai/vault-usecases/dist/usecases/workout-live.js

@@ -1,24 +1,79 @@
-import { memberActionIdV1Schema, workoutLiveApplyMemberActionV1Schema, workoutSessionSchema, workoutTemplateSchema, } from '@murphai/contracts';
+import { memberActionIdV1Schema, workoutLiveApplyMemberActionV1Schema, workoutLiveSnapshotMemberActionV1Schema, workoutSessionSchema, workoutTemplateSchema, } from '@murphai/contracts';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { deriveWorkoutActionBinding, deriveWorkoutSetRemovalBinding, hasAmbiguousWorkoutActionExerciseCoordinates, } from '@murphai/operator-config/workout-action-binding';
+import { deriveWorkoutSetRemovalBinding, hasAmbiguousWorkoutActionExerciseCoordinates, workoutActionBindingMatchesCurrentState, } from '@murphai/operator-config/workout-action-binding';
+import { encodeWorkoutSessionSnapshotAppCardUrl } from '@murphai/operator-config/assistant-response-cards';
 import { showWorkoutFormat } from './workout-format.js';
-import { addStructuredWorkoutRecord, editWorkoutRecord } from './workout.js';
-import { LIVE_WORKOUT_SOURCE_APP, buildLiveWorkoutCardEditor, buildLiveWorkoutSessionFromTemplate, elapsedDurationMinutes, hasLoggedWorkoutSet, } from './workout-live-model.js';
-import { assertTargetableLiveWorkout, compactSetPatch, findActiveLiveWorkouts, findLiveWorkoutsForMemberAction, normalizeLiveWorkoutActivityType, normalizeOptionalText, normalizeWorkoutTimestamp, optionalString, parseShownWorkout, requireLiveWorkoutSetOrder, requireNonEmptyText, requireString, resolveExerciseIndex, resolveLiveWorkout, updateLiveWorkoutExercises, updateLiveWorkoutExercisesAfterValidatedSetRemoval, withLiveWorkoutMutationLock, } from './workout-live-state.js';
+import { addStructuredWorkoutRecord, editWorkoutRecord, } from './workout.js';
+import { LIVE_WORKOUT_SOURCE_APP, buildLiveWorkoutCardEditor, buildLiveWorkoutCardSnapshot, buildLiveWorkoutSessionFromTemplate, elapsedDurationMinutes, hasCompletedFiniteLiveWorkoutPlan, hasLoggedWorkoutSet, isOpenLiveWorkout, } from './workout-live-model.js';
+import { assertTargetableLiveWorkout, compactSetPatch, findLiveWorkoutActionTargets, findLiveWorkoutRefreshTargets, normalizeLiveWorkoutActivityType, normalizeOptionalText, normalizeWorkoutTimestamp, optionalString, parseShownWorkout, requireLiveWorkoutSetOrder, requireNonEmptyText, requireString, resolveExerciseIndex, resolveLiveWorkout, updateLiveWorkoutExercises, withLiveWorkoutMutationLock, } from './workout-live-state.js';
 export * from './workout-live-model.js';
 export async function readLiveWorkoutCardEditor(input) {
     const shown = await resolveLiveWorkout({
         vault: input.vault,
         workoutId: input.workoutId,
-    }, { requireActive: true });
+    }, { requireOpen: true });
     const workout = parseShownWorkout(shown);
-    assertTargetableLiveWorkout(workout, `Workout ${shown.entity.id}`);
+    assertTargetableLiveWorkout(workout);
     return buildLiveWorkoutCardEditor({
         presentation: input.presentation,
         workout,
         workoutId: shown.entity.id,
     });
 }
+export async function readLiveWorkoutCardSnapshot(input) {
+    if (!workoutLiveSnapshotMemberActionV1Schema.safeParse(input.action).success) {
+        return { reason: 'workout_changed', status: 'rejected' };
+    }
+    const targets = await findLiveWorkoutRefreshTargets(input.vault, input.action.workoutBinding);
+    if (targets.length !== 1) {
+        return { reason: 'workout_changed', status: 'rejected' };
+    }
+    const cardUrl = buildLiveWorkoutMemberActionCardUrl({
+        presentation: input.action.presentation,
+        shown: targets[0],
+    });
+    if (cardUrl === null) {
+        return { reason: 'workout_changed', status: 'rejected' };
+    }
+    return {
+        result: { cardUrl, kind: 'workout.live.snapshot', version: 1 },
+        status: 'unchanged',
+    };
+}
+function buildLiveWorkoutMemberActionCardUrl(input) {
+    try {
+        const snapshot = buildLiveWorkoutCardSnapshot({
+            presentation: input.presentation.workout,
+            workout: parseShownWorkout(input.shown),
+            workoutId: input.shown.entity.id,
+        });
+        if (snapshot === null)
+            return null;
+        return encodeWorkoutSessionSnapshotAppCardUrl({
+            ...input.presentation,
+            ...(snapshot.editor === null ? {} : { editor: snapshot.editor }),
+            workout: snapshot.workout,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function buildLiveWorkoutApplySuccess(input) {
+    if (input.action.presentation === undefined) {
+        return { status: input.status };
+    }
+    const cardUrl = buildLiveWorkoutMemberActionCardUrl({
+        presentation: input.action.presentation,
+        shown: input.shown,
+    });
+    return cardUrl === null
+        ? { status: input.status }
+        : {
+            result: { cardUrl, kind: 'workout.live.apply', version: 1 },
+            status: input.status,
+        };
+}
 const MAX_LIVE_WORKOUT_EXERCISES = 100;
 const MAX_LIVE_WORKOUT_SETS_PER_EXERCISE = 150;
 export async function applyLiveWorkoutMemberAction(input) {
@@ -26,28 +81,45 @@ export async function applyLiveWorkoutMemberAction(input) {
         || !memberActionIdV1Schema.safeParse(input.actionId).success) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
-    return withLiveWorkoutMutationLock(input.vault, () => applyLiveWorkoutMemberActionWithLockHeld(input));
-}
-async function applyLiveWorkoutMemberActionWithLockHeld(input) {
-    const candidates = await findLiveWorkoutsForMemberAction(input.vault, input.actionId);
-    if (candidates.exactReplays.length > 0) {
-        if (candidates.exactReplays.length !== 1) {
+    const targets = await findLiveWorkoutActionTargets(input.vault, input.actionId, input.action.expectedWorkout.actionBinding);
+    if (targets.exactReplays.length > 0) {
+        if (targets.exactReplays.length !== 1) {
             return { reason: 'workout_changed', status: 'rejected' };
         }
-        return { status: 'unchanged' };
-    }
-    const active = candidates.active;
-    if (active.length === 0) {
-        return { reason: 'no_active_workout', status: 'rejected' };
+        return buildLiveWorkoutApplySuccess({
+            action: input.action,
+            shown: targets.exactReplays[0],
+            status: 'unchanged',
+        });
     }
-    if (active.length > 1) {
-        return { reason: 'multiple_active_workouts', status: 'rejected' };
+    if (targets.bindingMatches.length !== 1) {
+        return { reason: 'workout_changed', status: 'rejected' };
     }
-    const shown = active[0];
+    const workoutId = targets.bindingMatches[0].entity.id;
+    return withLiveWorkoutMutationLock(input.vault, workoutId, () => applyLiveWorkoutMemberActionWithLockHeld(input, workoutId));
+}
+async function applyLiveWorkoutMemberActionWithLockHeld(input, workoutId) {
+    let shown;
     let workout;
+    let acceptedAt;
     try {
+        shown = await resolveLiveWorkout({
+            vault: input.vault,
+            workoutId,
+        });
         workout = parseShownWorkout(shown);
-        assertTargetableLiveWorkout(workout, `Workout ${shown.entity.id}`);
+        if (workout.lastMemberActionId === input.actionId) {
+            return buildLiveWorkoutApplySuccess({
+                action: input.action,
+                shown,
+                status: 'unchanged',
+            });
+        }
+        if (!isOpenLiveWorkout(workout)) {
+            return { reason: 'workout_changed', status: 'rejected' };
+        }
+        assertTargetableLiveWorkout(workout);
+        acceptedAt = normalizeWorkoutTimestamp(input.acceptedAt, 'acceptedAt');
     }
     catch {
         return { reason: 'workout_changed', status: 'rejected' };
@@ -55,18 +127,16 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
     if (hasAmbiguousWorkoutActionExerciseCoordinates(workout)) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
-    if (input.action.expectedWorkout.actionBinding
-        !== deriveWorkoutActionBinding(shown.entity.id, workout)) {
+    if (!workoutActionBindingMatchesCurrentState(shown.entity.id, workout, input.action.expectedWorkout.actionBinding)) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
-    const acceptedAtMs = Date.parse(input.acceptedAt);
-    if (!Number.isFinite(acceptedAtMs)
-        || typeof workout.startedAt !== 'string'
-        || Date.parse(workout.startedAt) > acceptedAtMs) {
+    if (typeof workout.startedAt !== 'string'
+        || Date.parse(workout.startedAt) > Date.parse(acceptedAt)) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
-    const exercises = structuredClone(workout.exercises)
+    const beforeExercises = structuredClone(workout.exercises)
         .sort((left, right) => left.order - right.order);
+    const exercises = structuredClone(beforeExercises);
     if (input.action.mutations.some((mutation) => mutation.kind === 'set.remove')
         && input.action.expectedWorkout.setRemovalBinding
             !== deriveWorkoutSetRemovalBinding(shown.entity.id, exercises)) {
@@ -76,6 +146,7 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
     const appendMutations = input.action.mutations.filter((mutation) => mutation.kind === 'exercise.append');
+    const renameMutations = input.action.mutations.filter((mutation) => mutation.kind === 'exercise.rename');
     const removeMutations = input.action.mutations.filter((mutation) => mutation.kind === 'set.remove').sort((left, right) => left.exercisePosition === right.exercisePosition
         ? right.setPosition - left.setPosition
         : left.exercisePosition - right.exercisePosition);
@@ -107,11 +178,13 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
             ...(mutation.unitOverride
                 ? { unitOverride: mutation.unitOverride }
                 : {}),
+            setPlanIsFinite: true,
             sets: Array.from({ length: mutation.setCount }, (_, index) => ({
                 order: index + 1,
             })),
         });
     }
+    const completedPendingSet = memberActionCompletesPendingSet(exercises, input.action);
     if (!applyMemberActionSetPuts(exercises, existingSetMutations)) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
@@ -122,8 +195,7 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
         }
         exercise.sets.sort((left, right) => left.order - right.order);
         const existing = exercise.sets[mutation.setPosition - 1];
-        if (!existing
-            || exercise.sets.length <= 1) {
+        if (!existing || exercise.sets.length <= 1) {
             return { reason: 'workout_changed', status: 'rejected' };
         }
         exercise.sets.splice(mutation.setPosition - 1, 1);
@@ -134,6 +206,13 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
     if (!applyMemberActionSetAppends(exercises, newSetMutations)) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
+    if (!applyMemberActionExerciseRenames(exercises, renameMutations, input.action.expectedWorkout.exercises)) {
+        return { reason: 'workout_changed', status: 'rejected' };
+    }
+    if (renameMutations.length > 0
+        && hasAmbiguousWorkoutActionExerciseCoordinates({ exercises })) {
+        return { reason: 'workout_changed', status: 'rejected' };
+    }
     const parsed = workoutSessionSchema.safeParse({
         ...workout,
         exercises,
@@ -141,13 +220,59 @@ async function applyLiveWorkoutMemberActionWithLockHeld(input) {
     if (!parsed.success) {
         return { reason: 'workout_changed', status: 'rejected' };
     }
+    const endedAt = resolveObservedWorkoutEndBoundary({
+        afterExercises: parsed.data.exercises,
+        appendedExtraSet: newSetMutations.some((mutation) => mutation.result !== null),
+        beforeExercises,
+        completedPendingSet,
+        observedAt: acceptedAt,
+        workout,
+    });
     const changed = JSON.stringify(parsed.data.exercises)
-        !== JSON.stringify(workout.exercises);
-    const persistExercises = removeMutations.length > 0
-        ? updateLiveWorkoutExercisesAfterValidatedSetRemoval
-        : updateLiveWorkoutExercises;
-    await persistExercises(shown, workout, parsed.data.exercises, input.actionId);
-    return { status: changed ? 'applied' : 'unchanged' };
+        !== JSON.stringify(workout.exercises)
+        || endedAt !== undefined;
+    const updated = await updateLiveWorkoutExercises(shown, workout, parsed.data.exercises, {
+        ...(endedAt === undefined ? {} : { endedAt }),
+        lastMemberActionId: input.actionId,
+        observedAt: acceptedAt,
+    });
+    return buildLiveWorkoutApplySuccess({
+        action: input.action,
+        shown: updated,
+        status: changed ? 'applied' : 'unchanged',
+    });
+}
+function memberActionCompletesPendingSet(exercises, action) {
+    return action.mutations.some((mutation) => {
+        if (mutation.kind === 'set.append') {
+            return mutation.result !== null;
+        }
+        if (mutation.kind !== 'set.put') {
+            return false;
+        }
+        const exercise = exercises[mutation.exercisePosition - 1];
+        const set = exercise?.sets
+            .slice()
+            .sort((left, right) => left.order - right.order)[mutation.setPosition - 1];
+        return set !== undefined && !hasLoggedWorkoutSet(set);
+    });
+}
+function resolveObservedWorkoutEndBoundary(input) {
+    if (input.workout.endedAt !== undefined) {
+        return input.appendedExtraSet ? input.observedAt : undefined;
+    }
+    if (!input.completedPendingSet) {
+        return undefined;
+    }
+    const beforeComplete = hasCompletedFiniteLiveWorkoutPlan({
+        ...input.workout,
+        exercises: input.beforeExercises,
+    });
+    const afterComplete = hasCompletedFiniteLiveWorkoutPlan({
+        ...input.workout,
+        exercises: input.afterExercises,
+    });
+    return !beforeComplete && afterComplete ? input.observedAt : undefined;
 }
 function applyMemberActionSetPuts(exercises, mutations) {
     for (const mutation of mutations) {
@@ -177,6 +302,20 @@ function applyMemberActionSetPuts(exercises, mutations) {
     }
     return true;
 }
+function applyMemberActionExerciseRenames(exercises, mutations, expectedExercises) {
+    for (const mutation of mutations) {
+        const exercise = exercises[mutation.exercisePosition - 1];
+        const expectedExercise = expectedExercises[mutation.exercisePosition - 1];
+        if (!exercise
+            || !expectedExercise
+            || exercise.name !== expectedExercise.name
+            || mutation.name === expectedExercise.name) {
+            return false;
+        }
+        exercise.name = mutation.name;
+    }
+    return true;
+}
 function applyMemberActionSetAppends(exercises, mutations) {
     for (const mutation of mutations) {
         const exercise = exercises[mutation.exercisePosition - 1];
@@ -284,22 +423,58 @@ function projectMemberActionWorkoutSetResult(set, kind) {
         weightUnit: set.weightUnit ?? null,
     };
 }
-export async function startLiveWorkout(input) {
-    return withLiveWorkoutMutationLock(input.vault, () => startLiveWorkoutWithLockHeld(input));
+function buildInitialLiveWorkoutExercises(exercises) {
+    if (exercises.length > MAX_LIVE_WORKOUT_EXERCISES) {
+        throw new VaultCliError('invalid_option', `Live workouts support at most ${MAX_LIVE_WORKOUT_EXERCISES} exercises.`);
+    }
+    return exercises.map((exercise, index) => {
+        const setCount = exercise.setCount ?? 1;
+        if (!Number.isInteger(setCount)
+            || setCount < 1
+            || setCount > MAX_LIVE_WORKOUT_SETS_PER_EXERCISE) {
+            throw new VaultCliError('invalid_option', `Exercise set count must be between 1 and ${MAX_LIVE_WORKOUT_SETS_PER_EXERCISE}.`);
+        }
+        if (exercise.reps !== undefined
+            && (!Number.isInteger(exercise.reps)
+                || exercise.reps < 1
+                || exercise.reps > 999)) {
+            throw new VaultCliError('invalid_option', 'Exercise repetitions per set must be an integer between 1 and 999.');
+        }
+        const sourceExerciseId = normalizeOptionalText(exercise.sourceExerciseId);
+        const groupId = normalizeOptionalText(exercise.groupId);
+        const note = normalizeOptionalText(exercise.note);
+        return {
+            name: requireNonEmptyText(exercise.name, 'Exercise name is required.'),
+            order: index + 1,
+            ...(sourceExerciseId ? { sourceExerciseId } : {}),
+            ...(groupId ? { groupId } : {}),
+            ...(exercise.mode ? { mode: exercise.mode } : {}),
+            ...(exercise.unitOverride ? { unitOverride: exercise.unitOverride } : {}),
+            ...(note ? { note } : {}),
+            ...(exercise.reps === undefined
+                ? {}
+                : { memberRepsPerSet: exercise.reps }),
+            setPlanIsFinite: exercise.setCount !== undefined,
+            sets: Array.from({ length: setCount }, (_, setIndex) => ({
+                order: setIndex + 1,
+            })),
+        };
+    });
 }
-async function startLiveWorkoutWithLockHeld(input) {
+export async function startLiveWorkout(input) {
     const routineLookup = input.routine === undefined
         ? undefined
         : requireNonEmptyText(input.routine, 'Workout routine lookup is required.');
-    const active = await findActiveLiveWorkouts(input.vault);
-    if (active.length > 0) {
-        throw new VaultCliError('command_failed', `Workout ${active[0]?.entity.id ?? ''} is already active. Finish or delete it before starting another live workout.`, { activeWorkoutIds: active.map((entry) => entry.entity.id) });
-    }
-    const startedAt = normalizeWorkoutTimestamp(input.startedAt ?? new Date().toISOString(), 'startedAt');
+    const observedAt = new Date().toISOString();
+    const startedAt = normalizeWorkoutTimestamp(input.startedAt ?? observedAt, 'startedAt');
     const name = normalizeOptionalText(input.name);
     const note = normalizeOptionalText(input.note);
     const activityTypeOverride = normalizeOptionalText(input.activityType);
-    const durationMinutes = elapsedDurationMinutes(startedAt, new Date().toISOString());
+    const initialExercises = input.exercises ?? [];
+    const durationMinutes = elapsedDurationMinutes(startedAt, observedAt);
+    if (routineLookup !== undefined && initialExercises.length > 0) {
+        throw new VaultCliError('invalid_option', '--exercise cannot be combined with --routine.');
+    }
     if (routineLookup !== undefined) {
         const routine = await showWorkoutFormat(input.vault, routineLookup);
         const routineTitle = requireString(routine.entity.title, 'Workout routine title is missing.');
@@ -310,7 +485,7 @@ async function startLiveWorkoutWithLockHeld(input) {
             startedAt,
             sessionNote: note,
         });
-        assertTargetableLiveWorkout(workout, `Workout routine "${routineTitle}"`);
+        assertTargetableLiveWorkout(workout);
         return addStructuredWorkoutRecord({
             vault: input.vault,
             draft: {
@@ -332,7 +507,7 @@ async function startLiveWorkoutWithLockHeld(input) {
         sourceApp: LIVE_WORKOUT_SOURCE_APP,
         startedAt,
         ...(note ? { sessionNote: note } : {}),
-        exercises: [],
+        exercises: buildInitialLiveWorkoutExercises(initialExercises),
     });
     return addStructuredWorkoutRecord({
         vault: input.vault,
@@ -349,24 +524,22 @@ async function startLiveWorkoutWithLockHeld(input) {
         },
     });
 }
-export async function showActiveLiveWorkout(input) {
-    return resolveLiveWorkout(input, { requireActive: true });
-}
 export async function addLiveWorkoutExercise(input) {
-    return withLiveWorkoutMutationLock(input.vault, () => addLiveWorkoutExerciseWithLockHeld(input));
+    const observedAt = new Date().toISOString();
+    return withLiveWorkoutMutationLock(input.vault, input.workoutId, () => addLiveWorkoutExerciseWithLockHeld(input, observedAt));
 }
-async function addLiveWorkoutExerciseWithLockHeld(input) {
-    const shown = await resolveLiveWorkout(input, { requireActive: true });
+async function addLiveWorkoutExerciseWithLockHeld(input, observedAt) {
+    const shown = await resolveLiveWorkout(input, { requireOpen: true });
     const workout = parseShownWorkout(shown);
-    assertTargetableLiveWorkout(workout, `Workout ${shown.entity.id}`);
+    assertTargetableLiveWorkout(workout);
     const exercises = structuredClone(workout.exercises);
     const order = input.order;
     const setCount = input.setCount ?? 1;
     if (!Number.isInteger(order) || order < 1) {
         throw new VaultCliError('invalid_option', 'Exercise order must be a positive integer.');
     }
-    if (!Number.isInteger(setCount) || setCount < 1 || setCount > 150) {
-        throw new VaultCliError('invalid_option', 'Exercise set count must be between 1 and 150.');
+    if (!Number.isInteger(setCount) || setCount < 1 || setCount > MAX_LIVE_WORKOUT_SETS_PER_EXERCISE) {
+        throw new VaultCliError('invalid_option', `Exercise set count must be between 1 and ${MAX_LIVE_WORKOUT_SETS_PER_EXERCISE}.`);
     }
     const name = requireNonEmptyText(input.name, 'Exercise name is required.');
     const sourceExerciseId = normalizeOptionalText(input.sourceExerciseId);
@@ -380,6 +553,7 @@ async function addLiveWorkoutExerciseWithLockHeld(input) {
         ...(input.mode ? { mode: input.mode } : {}),
         ...(input.unitOverride ? { unitOverride: input.unitOverride } : {}),
         ...(note ? { note } : {}),
+        setPlanIsFinite: input.setCount !== undefined,
         sets: Array.from({ length: setCount }, (_, index) => ({ order: index + 1 })),
     };
     const parsedProposed = workoutSessionSchema.parse({
@@ -397,30 +571,80 @@ async function addLiveWorkoutExerciseWithLockHeld(input) {
     }
     exercises.push(parsedProposed);
     exercises.sort((left, right) => left.order - right.order);
-    return updateLiveWorkoutExercises(shown, workout, exercises);
+    return updateLiveWorkoutExercises(shown, workout, exercises, { observedAt });
+}
+export async function setLiveWorkoutExerciseReps(input) {
+    const observedAt = new Date().toISOString();
+    return withLiveWorkoutMutationLock(input.vault, input.workoutId, () => setLiveWorkoutExerciseRepsWithLockHeld(input, observedAt));
+}
+async function setLiveWorkoutExerciseRepsWithLockHeld(input, observedAt) {
+    const clear = input.clear === true;
+    const reps = input.reps;
+    const hasReps = reps !== undefined;
+    if (clear === hasReps) {
+        throw new VaultCliError('invalid_option', 'Pass exactly one of --reps or --clear.');
+    }
+    if (reps !== undefined
+        && (!Number.isInteger(reps) || reps < 1 || reps > 999)) {
+        throw new VaultCliError('invalid_option', 'Exercise repetitions per set must be an integer between 1 and 999.');
+    }
+    const shown = await resolveLiveWorkout(input);
+    const workout = parseShownWorkout(shown);
+    assertTargetableLiveWorkout(workout);
+    const exercises = structuredClone(workout.exercises);
+    const exerciseIndex = resolveExerciseIndex(exercises, input);
+    const exercise = exercises[exerciseIndex];
+    if ((clear && exercise.memberRepsPerSet === undefined)
+        || (!clear && exercise.memberRepsPerSet === reps)) {
+        return shown;
+    }
+    if (clear) {
+        return editWorkoutRecord({
+            vault: shown.vault,
+            lookup: shown.entity.id,
+            clear: [`workout.exercises.${exerciseIndex}.memberRepsPerSet`],
+        });
+    }
+    if (reps !== undefined) {
+        exercise.memberRepsPerSet = reps;
+    }
+    exercises[exerciseIndex] = exercise;
+    return updateLiveWorkoutExercises(shown, workout, exercises, { observedAt });
 }
 export async function logLiveWorkoutSet(input) {
-    return withLiveWorkoutMutationLock(input.vault, () => logLiveWorkoutSetWithLockHeld(input));
+    const observedAt = new Date().toISOString();
+    return withLiveWorkoutMutationLock(input.vault, input.workoutId, () => logLiveWorkoutSetWithLockHeld(input, observedAt));
 }
-async function logLiveWorkoutSetWithLockHeld(input) {
+async function logLiveWorkoutSetWithLockHeld(input, observedAt) {
     const setOrder = requireLiveWorkoutSetOrder(input.setOrder);
-    const shown = await resolveLiveWorkout(input, { requireActive: true });
+    const shown = await resolveLiveWorkout(input);
     const workout = parseShownWorkout(shown);
-    assertTargetableLiveWorkout(workout, `Workout ${shown.entity.id}`);
-    const exercises = structuredClone(workout.exercises);
+    assertTargetableLiveWorkout(workout);
+    const beforeExercises = structuredClone(workout.exercises);
+    const exercises = structuredClone(beforeExercises);
     const exerciseIndex = resolveExerciseIndex(exercises, input);
     const exercise = exercises[exerciseIndex];
+    const setIndex = exercise.sets.findIndex((set) => set.order === setOrder);
+    const currentSet = setIndex >= 0 ? exercise.sets[setIndex] : undefined;
     const patch = compactSetPatch(input);
+    if (input.reps === undefined
+        && exercise.memberRepsPerSet !== undefined
+        && (currentSet === undefined || !hasLoggedWorkoutSet(currentSet))) {
+        patch.reps = exercise.memberRepsPerSet;
+    }
     if (Object.keys(patch).length === 0) {
-        throw new VaultCliError('invalid_option', 'Log at least one set value or note.');
+        if (currentSet !== undefined
+            && hasLoggedWorkoutSet(currentSet)
+            && exercise.memberRepsPerSet !== undefined) {
+            return shown;
+        }
+        throw new VaultCliError('invalid_option', 'Log at least one set value or establish --reps for every set of this exercise first.');
     }
-    const setIndex = exercise.sets.findIndex((set) => set.order === setOrder);
-    const currentSet = setIndex >= 0 ? exercise.sets[setIndex] : undefined;
     if (currentSet === undefined && input.requireExistingSet) {
         throw new VaultCliError('not_found', `No set ${setOrder} exists for ${exercise.name}.`);
     }
-    if (currentSet === undefined &&
-        exercise.sets.length >= MAX_LIVE_WORKOUT_SETS_PER_EXERCISE) {
+    if (currentSet === undefined
+        && exercise.sets.length >= MAX_LIVE_WORKOUT_SETS_PER_EXERCISE) {
         throw new VaultCliError('invalid_operation', `Each exercise supports at most ${MAX_LIVE_WORKOUT_SETS_PER_EXERCISE} sets.`);
     }
     const parsedSet = workoutSessionSchema.parse({
@@ -438,6 +662,10 @@ async function logLiveWorkoutSetWithLockHeld(input) {
     if (currentSet && JSON.stringify(currentSet) === JSON.stringify(parsedSet)) {
         return shown;
     }
+    const appendedExtraSet = currentSet === undefined
+        && setOrder > exercise.sets.reduce((maximum, set) => Math.max(maximum, set.order), 0);
+    const completedPendingSet = currentSet === undefined
+        || !hasLoggedWorkoutSet(currentSet);
     if (setIndex >= 0) {
         exercise.sets[setIndex] = parsedSet;
     }
@@ -446,16 +674,28 @@ async function logLiveWorkoutSetWithLockHeld(input) {
         exercise.sets.sort((left, right) => left.order - right.order);
     }
     exercises[exerciseIndex] = exercise;
-    return updateLiveWorkoutExercises(shown, workout, exercises);
+    const endedAt = resolveObservedWorkoutEndBoundary({
+        afterExercises: exercises,
+        appendedExtraSet,
+        beforeExercises,
+        completedPendingSet,
+        observedAt,
+        workout,
+    });
+    return updateLiveWorkoutExercises(shown, workout, exercises, {
+        ...(endedAt === undefined ? {} : { endedAt }),
+        observedAt,
+    });
 }
 export async function clearLiveWorkoutSet(input) {
-    return withLiveWorkoutMutationLock(input.vault, () => clearLiveWorkoutSetWithLockHeld(input));
+    const observedAt = new Date().toISOString();
+    return withLiveWorkoutMutationLock(input.vault, input.workoutId, () => clearLiveWorkoutSetWithLockHeld(input, observedAt));
 }
-async function clearLiveWorkoutSetWithLockHeld(input) {
+async function clearLiveWorkoutSetWithLockHeld(input, observedAt) {
     const setOrder = requireLiveWorkoutSetOrder(input.setOrder);
-    const shown = await resolveLiveWorkout(input, { requireActive: true });
+    const shown = await resolveLiveWorkout(input);
     const workout = parseShownWorkout(shown);
-    assertTargetableLiveWorkout(workout, `Workout ${shown.entity.id}`);
+    assertTargetableLiveWorkout(workout);
     const exercises = structuredClone(workout.exercises);
     const exerciseIndex = resolveExerciseIndex(exercises, input);
     const exercise = exercises[exerciseIndex];
@@ -473,16 +713,13 @@ async function clearLiveWorkoutSetWithLockHeld(input) {
     }
     exercise.sets[setIndex] = clearedSet;
     exercises[exerciseIndex] = exercise;
-    return updateLiveWorkoutExercises(shown, workout, exercises);
+    return updateLiveWorkoutExercises(shown, workout, exercises, { observedAt });
 }
 export async function finishLiveWorkout(input) {
-    return withLiveWorkoutMutationLock(input.vault, () => finishLiveWorkoutWithLockHeld(input));
+    return withLiveWorkoutMutationLock(input.vault, input.workoutId, () => finishLiveWorkoutWithLockHeld(input));
 }
 async function finishLiveWorkoutWithLockHeld(input) {
-    const shown = await resolveLiveWorkout(input, {
-        requireActive: input.workoutId === undefined,
-        allowCompleted: input.workoutId !== undefined,
-    });
+    const shown = await resolveLiveWorkout(input);
     const workout = parseShownWorkout(shown);
     if (workout.endedAt) {
         return shown;