@lilaquadrat/studio 12.1.0 → 12.3.0

package/lib/tests/shiftPlanning.spec.js

@@ -0,0 +1,1162 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, jest } from '@jest/globals';
+import mongodb from 'mongo-mock';
+import { ObjectId } from 'mongodb';
+import Models from '../src/classes/models.class.js';
+import plansService from '../src/services/shiftPlans.service.js';
+import daysService from '../src/services/shiftPlanDays.service.js';
+import shiftsService from '../src/services/shifts.service.js';
+import settingsService from '../src/services/shiftPlanningSettings.service.js';
+import absencesService from '../src/services/employeeAbsences.service.js';
+import areasService from '../src/services/workAreas.service.js';
+import AreaModel from '../src/models/workAreas.model.js';
+import ShiftPlanModel from '../src/models/shiftPlan.model.js';
+import DayModel from '../src/models/shiftPlanDays.model.js';
+import ShiftModel from '../src/models/shift.model.js';
+import SettingsModel from '../src/models/shiftPlanningSettings.model.js';
+import AbsenceModel from '../src/models/employeeAbsence.model.js';
+import ListsModel from '../src/models/lists.model.js';
+import ParticipantsModel from '../src/models/listsParticipants.model.js';
+import CustomersModel from '../src/models/customers.model.js';
+import StructureModel from '../src/models/structure.model.js';
+import HistoryModel from '../src/models/history.model.js';
+import participantsService from '../src/services/listParticipants.service.js';
+const options = { company: 'hotel', project: 'hotel-project', user: 'planner', app: 'studio' };
+const listId = new ObjectId();
+const categoryId = new ObjectId();
+const customerId = new ObjectId();
+const participantId = new ObjectId();
+const secondCustomerId = new ObjectId();
+const secondParticipantId = new ObjectId();
+const housekeepingAreaId = new ObjectId();
+const receptionAreaId = new ObjectId();
+const day = '2026-10-05';
+const nextDay = '2026-10-06';
+const customer = {
+    _id: customerId, id: 'anna', company: options.company, type: 'person', name: 'Anna',
+    email: 'anna@example.org', emailConfirmed: true,
+    accounts: [{ account: 'anna-account', app: 'members', project: options.project }],
+    note: 'private',
+};
+const list = {
+    _id: listId, company: options.company, project: options.project, name: 'Hotel staff',
+    mode: 'reservation', state: 'closed', agreements: [],
+    categories: [{ _id: categoryId, id: 'housekeeping', name: 'Housekeeping' }],
+};
+const participant = {
+    _id: participantId, company: options.company, project: options.project, list: listId,
+    user: customerId, category: 'housekeeping', state: 'confirmed', agreements: [], note: 'private participant note',
+};
+const policy = () => ({
+    daytime: { start: '06:00', end: '22:00' }, nighttime: { start: '22:00', end: '06:00' },
+    maximumConsecutiveWorkingDays: { enabled: false, days: 6 },
+    maximumDailyWorkMinutes: { enabled: false, minutes: 480 },
+    minimumRest: { enabled: false, minutes: 660 },
+    breaks: { enabled: false, maximumContinuousWorkMinutes: 360, minimumQualifyingBreakMinutes: 15,
+        requirements: [{ afterWorkMinutes: 360, minimumTotalBreakMinutes: 30 }] },
+    absenceEnforcement: true,
+});
+const areaLinks = () => [{ area: housekeepingAreaId }, { area: receptionAreaId }];
+const planInput = (list = listId, overrides = {}) => ({
+    list, name: 'Hotel week', timeZone: 'Europe/Berlin',
+    settingsOverrides: {},
+    ...overrides,
+});
+const planAreas = (plan) => plan.days.flatMap((entry) => entry.areas ?? []);
+const dayId = (plan, date) => plan.days.find((entry) => entry.date === date)._id;
+const createDays = async (plan, dayOptions, entries) => {
+    for (const entry of entries)
+        await daysService.createDay(plan, entry, dayOptions);
+};
+async function setupPlan() {
+    await settingsService.changeSettings({ settings: policy() }, options);
+    const created = await plansService.createPlan(planInput(), options);
+    await createDays(created._id, options, [{ date: day, areas: areaLinks() }, { date: nextDay, areas: areaLinks() }]);
+    return (await plansService.singlePlan(created._id, options));
+}
+async function otherProjectPlan(list, projectOptions, settingsOverrides = {}) {
+    const area = await areasService.createWorkArea({ name: 'Housekeeping' }, projectOptions);
+    const created = await plansService.createPlan(planInput(list, { settingsOverrides }), projectOptions);
+    await createDays(created._id, projectOptions, [
+        { date: day, areas: [{ area: area._id }] },
+        { date: nextDay, areas: [{ area: area._id }] },
+    ]);
+    return (await plansService.singlePlan(created._id, projectOptions));
+}
+const shiftInput = (plan, area, changes = {}) => {
+    const date = changes.day ?? day;
+    const dayDoc = plan.days.find((entry) => entry.date === date);
+    const base = {
+        area, title: 'Morning', start: `${date}T08:00:00+02:00`, end: `${date}T12:00:00+02:00`,
+        assignments: [{ participant: participantId }], ...changes,
+    };
+    return { ...base, day: dayDoc._id };
+};
+describe('shift planning', () => {
+    let client;
+    const models = [AreaModel, ShiftPlanModel, DayModel, ShiftModel, SettingsModel, AbsenceModel, ListsModel, ParticipantsModel, CustomersModel, StructureModel, HistoryModel];
+    beforeAll(async () => {
+        mongodb.max_delay = 0;
+        client = await mongodb.MongoClient.connect('mongodb://localhost:27017/shift-planning-tests');
+        const registry = new Models();
+        for (const model of models)
+            registry.register(model.name, model);
+        await Promise.all(registry.injectDatabaseConnection(client, undefined, true));
+        for (const model of [AreaModel, ShiftPlanModel, DayModel, ShiftModel, SettingsModel, AbsenceModel]) {
+            const collection = model.db;
+            const insertOne = collection.insertOne.bind(collection);
+            // mongo-mock otherwise generates IDs from its own older BSON implementation.
+            jest.spyOn(collection, 'insertOne').mockImplementation((async (document) => {
+                return insertOne({ ...document, _id: document._id ?? new ObjectId() });
+            }));
+            // Adapt mongo-mock's legacy driver wrapper to the production driver's document return.
+            jest.spyOn(collection, 'findOneAndUpdate').mockImplementation((async (filter, update) => {
+                await collection.updateOne(filter, update);
+                return collection.findOne(filter);
+            }));
+        }
+        const customers = CustomersModel.db;
+        const findCustomer = customers.findOne.bind(customers);
+        // mongo-mock's sift version matches separate elements for compound $elemMatch conditions.
+        jest.spyOn(customers, 'findOne').mockImplementation((async (filter, findOptions) => {
+            const result = await findCustomer(filter, findOptions);
+            const accounts = filter.accounts;
+            if (accounts && typeof accounts === 'object' && '$elemMatch' in accounts && result?.type === 'person') {
+                const expected = accounts.$elemMatch;
+                if (!result.accounts?.some((entry) => entry.account === expected.account && entry.app === expected.app && entry.project === expected.project))
+                    return null;
+            }
+            return result;
+        }));
+    });
+    beforeEach(async () => {
+        for (const model of models) {
+            while (await model.db.countDocuments({}))
+                await model.db.deleteOne({});
+        }
+        await ListsModel.db.insertOne(list);
+        await CustomersModel.db.insertOne(customer);
+        await CustomersModel.db.insertOne({ ...customer, _id: secondCustomerId, id: 'ben', accounts: [] });
+        await ParticipantsModel.db.insertOne(participant);
+        await ParticipantsModel.db.insertOne({ ...participant, _id: secondParticipantId, user: secondCustomerId });
+        await AreaModel.db.insertOne({ _id: housekeepingAreaId, company: options.company, project: options.project, name: 'Housekeeping' });
+        await AreaModel.db.insertOne({ _id: receptionAreaId, company: options.company, project: options.project, name: 'Reception' });
+    });
+    afterAll(async () => {
+        jest.restoreAllMocks();
+        await client.close();
+    });
+    it('allows empty setup without company settings and links stable work areas on a closed list', async () => {
+        const empty = await plansService.createPlan(planInput(listId), options);
+        expect(empty.effectiveSettings).toBeNull();
+        await createDays(empty._id, options, [{ date: day, areas: areaLinks() }]);
+        const changed = (await plansService.singlePlan(empty._id, options));
+        expect(planAreas(changed)[0].area).toBeInstanceOf(ObjectId);
+        const again = await plansService.changePlan(empty._id, {
+            name: changed.name, timeZone: changed.timeZone, settingsOverrides: {},
+        }, options);
+        expect(planAreas(again)[0].area.equals(planAreas(changed)[0].area)).toBe(true);
+        expect(again).not.toHaveProperty('version');
+        expect((await settingsService.singleSettings(options))).toBeNull();
+    });
+    it('links, keeps and clears the employee list through full-object plan changes', async () => {
+        const otherListId = new ObjectId();
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, name: 'Events' });
+        const created = await plansService.createPlan(planInput(listId), options);
+        expect(created.list.equals(listId)).toBe(true);
+        const kept = await plansService.changePlan(created._id, planInput(), options);
+        expect(kept.list.equals(listId)).toBe(true);
+        const relinked = await plansService.changePlan(created._id, planInput(otherListId), options);
+        expect(relinked.list.equals(otherListId)).toBe(true);
+        const cleared = await plansService.changePlan(created._id, { name: created.name, timeZone: created.timeZone, settingsOverrides: {} }, options);
+        expect(cleared.list).toBeUndefined();
+    });
+    it('resolves assignments against the linked plan list for a shift persisted before the link', async () => {
+        await settingsService.changeSettings({ settings: policy() }, options);
+        const created = await plansService.createPlan({ name: 'Unlinked', timeZone: 'Europe/Berlin', settingsOverrides: {} }, options);
+        await createDays(created._id, options, [{ date: day, areas: [{ area: housekeepingAreaId }] }]);
+        const unlinked = (await plansService.singlePlan(created._id, options));
+        const shift = await shiftsService.createShift(unlinked._id, shiftInput(unlinked, planAreas(unlinked)[0].area, { assignments: [] }), options);
+        expect(shift).not.toHaveProperty('list');
+        await plansService.changePlan(created._id, planInput(), options);
+        const linked = (await plansService.singlePlan(created._id, options));
+        const updated = await shiftsService.replaceAssignments(linked._id, shift._id, { assignments: [{ participant: participantId }] }, options);
+        expect(updated.assignments).toHaveLength(1);
+        expect(updated.assignments[0].customer.toHexString()).toBe(customerId.toHexString());
+    });
+    it('creates separate same-name/same-date department plans from one employee pool', async () => {
+        const first = await setupPlan();
+        const count = await HistoryModel.db.countDocuments({});
+        const second = await plansService.createPlan(planInput(), options);
+        expect(second._id.equals(first._id)).toBe(false);
+        expect(await HistoryModel.db.countDocuments({})).toBe(count + 1);
+        await createDays(second._id, options, [{ date: day, areas: areaLinks() }, { date: nextDay, areas: areaLinks() }]);
+        const secondRead = (await plansService.singlePlan(second._id, options));
+        expect(planAreas(secondRead)[0].area.equals(planAreas(first)[0].area)).toBe(true);
+    });
+    it('validates work area category ownership and duplicate plan/day identities', async () => {
+        const plan = await setupPlan();
+        const area = planAreas(plan)[0].area;
+        await expect(plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area, categoryIds: [new ObjectId()] }] }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area, categoryIds: [categoryId, categoryId] }] }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area, categoryIds: [categoryId] }, { area, categoryIds: [categoryId] }] }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area: new ObjectId(), categoryIds: [categoryId] }] }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await daysService.createDay(plan._id, { date: '2026-10-19', areas: [] }, options);
+        await expect(daysService.createDay(plan._id, { date: '2026-10-19', name: 'Duplicate', areas: [] }, options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it('binds and clears per-work-area categories on the plan', async () => {
+        const plan = await setupPlan();
+        const area = planAreas(plan)[0].area;
+        const bound = await plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [{ area, categoryIds: [categoryId] }] }), options);
+        expect(bound.workAreaCategories).toHaveLength(1);
+        expect(bound.workAreaCategories[0].categoryIds[0].equals(categoryId)).toBe(true);
+        const cleared = await plansService.changePlan(plan._id, planInput(listId, { workAreaCategories: [] }), options);
+        expect(cleared.workAreaCategories).toEqual([]);
+        const untouched = await plansService.changePlan(plan._id, planInput(listId), options);
+        expect(untouched.workAreaCategories).toEqual([]);
+    });
+    it('stores, preserves and clears the default participant state', async () => {
+        const plan = await setupPlan();
+        const set = await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'confirmed' }), options);
+        expect(set.defaultParticipantState).toBe('confirmed');
+        const touched = await plansService.changePlan(plan._id, planInput(listId, { name: 'Renamed' }), options);
+        expect(touched.defaultParticipantState).toBe('confirmed');
+        const cleared = await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: null }), options);
+        expect(cleared.defaultParticipantState).toBeNull();
+        await expect(plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'bogus' }), options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it.each([
+        { timeZone: 'Bad/Timezone' },
+    ])('rejects invalid plan domain values: %j', async (changes) => {
+        await expect(plansService.createPlan({ ...planInput(), ...changes }, options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await ShiftPlanModel.db.countDocuments({})).toBe(0);
+    });
+    it.each([
+        { date: '2026-02-30' },
+        { date: '2026-10-15', areas: [{ area: housekeepingAreaId, unknown: true }] },
+    ])('rejects invalid day schema/domain values: %j', async (changes) => {
+        const plan = await setupPlan();
+        const count = await DayModel.db.countDocuments({});
+        await expect(daysService.createDay(plan._id, changes, options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await DayModel.db.countDocuments({})).toBe(count);
+    });
+    it('binds a shift to one work area and derives customers', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[1].area, {
+            assignments: [{ participant: participantId }, { participant: secondParticipantId }],
+        }), options);
+        expect(shift.assignments.map((entry) => entry.customer.toHexString())).toEqual([customerId.toHexString(), secondCustomerId.toHexString()]);
+        expect(shift.area.equals(planAreas(plan)[1].area)).toBe(true);
+        expect(shift).not.toHaveProperty('version');
+        expect(shift.start).toBe(`${day}T06:00:00.000Z`);
+        expect(shift.violations).toEqual([]);
+        const separate = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            start: `${day}T13:00:00+02:00`, end: `${day}T15:00:00+02:00`,
+        }), options);
+        expect(separate.title).toBe(shift.title);
+        expect(separate._id.equals(shift._id)).toBe(false);
+        const history = await HistoryModel.db.findOne({ 'history.parent': shift._id });
+        expect(history).toMatchObject({ assignments: [{ customer: customerId }, { customer: secondCustomerId }], history: { model: 'shifts', reason: 'create', user: options.user } });
+    });
+    it('stores shift structures and people requirements and replaces them on change', async () => {
+        const plan = await setupPlan();
+        const structureId = '507f1f77bcf86cd799439011';
+        const secondStructureId = '507f1f77bcf86cd799439012';
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            structures: [{ structure: structureId, constraint: 'required', value: true }, { structure: secondStructureId, constraint: 'forbidden', value: 'option-b' }], requiredPeople: 3, matchingPeople: 2,
+        }), options);
+        expect(shift.structures).toEqual([{ structure: structureId, constraint: 'required', value: true }, { structure: secondStructureId, constraint: 'forbidden', value: 'option-b' }]);
+        expect(shift.requiredPeople).toBe(3);
+        expect(shift.matchingPeople).toBe(2);
+        const { assignments, ...cleared } = shiftInput(plan, planAreas(plan)[0].area, { requiredPeople: 4, matchingPeople: 1 });
+        const updated = await shiftsService.changeShift(plan._id, shift._id, cleared, options);
+        expect(updated.requiredPeople).toBe(4);
+        expect(updated.matchingPeople).toBe(1);
+        expect(updated).not.toHaveProperty('structures');
+        const { assignments: reused, ...restaffed } = shiftInput(plan, planAreas(plan)[0].area, { structures: [{ structure: structureId, constraint: 'required' }], requiredPeople: 2 });
+        const withStructures = await shiftsService.changeShift(plan._id, shift._id, restaffed, options);
+        expect(withStructures.structures).toEqual([{ structure: structureId, constraint: 'required' }]);
+        expect(withStructures.requiredPeople).toBe(2);
+        expect(withStructures.matchingPeople).toBe(1);
+    });
+    it('rejects duplicate customers, wrong participant ownership and unknown area', async () => {
+        const plan = await setupPlan();
+        await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { user: customerId } });
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            assignments: [{ participant: participantId }, { participant: secondParticipantId }],
+        }), options)).rejects.toThrow('VALIDATION_FAILED');
+        await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { project: 'foreign' } });
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, new ObjectId()), options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await ShiftModel.db.countDocuments({})).toBe(0);
+    });
+    it.each(['blocked', 'unchecked', 'notuseful', 'canceled'])('refuses new %s participants', async (state) => {
+        const plan = await setupPlan();
+        await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state } });
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it.each(['enlisted', 'confirmed', 'reserved', 'waiting', 'finalized', 'paid'])('accepts current admin-default state %s', async (state) => {
+        const plan = await setupPlan();
+        await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state } });
+        expect((await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).assignments).toHaveLength(1);
+    });
+    it('preserves canceled/removed assignments, reports attention and keeps own member projection private', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state: 'canceled' } });
+        expect((await shiftsService.singleShift(plan._id, shift._id, options)).unavailableParticipantIds).toEqual([participantId.toHexString()]);
+        await ParticipantsModel.db.deleteOne({ _id: participantId });
+        const before = await HistoryModel.db.countDocuments({ 'history.parent': shift._id });
+        await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [{ participant: participantId }] }, options);
+        expect(await HistoryModel.db.countDocuments({ 'history.parent': shift._id })).toBe(before);
+        const memberOptions = { ...options, user: 'anna-account', app: 'members' };
+        const own = await shiftsService.myShifts(customerId, {}, memberOptions);
+        expect(own.all).toBe(1);
+        expect(Object.keys(own.data[0]).sort()).toEqual(['_id', 'area', 'breaks', 'day', 'end', 'list', 'plan', 'start', 'title']);
+        expect(own.data[0].area).not.toHaveProperty('categoryIds');
+        expect(own.data[0]).not.toHaveProperty('history');
+        await expect(shiftsService.myShifts(secondCustomerId, {}, memberOptions)).rejects.toThrow('MEMBER_NOT_ALLOWED');
+    });
+    it('rejects mixed-account tenant/project/app membership instead of matching dotted fields independently', async () => {
+        await CustomersModel.db.updateOne({ _id: customerId }, { $set: { accounts: [
+                    { account: 'anna-account', app: 'foreign', project: options.project },
+                    { account: 'other', app: 'members', project: options.project },
+                ] } });
+        expect((await CustomersModel.db.findOne({ _id: customerId })).accounts).toEqual([
+            { account: 'anna-account', app: 'foreign', project: options.project },
+            { account: 'other', app: 'members', project: options.project },
+        ]);
+        await expect(shiftsService.myShifts(customerId, {}, { ...options, user: 'anna-account', app: 'members' })).rejects.toThrow('MEMBER_NOT_ALLOWED');
+    });
+    it('replaces assignment sets, retains empty sets and makes reordered sets a history no-op', async () => {
+        const plan = await setupPlan();
+        const assignments = [{ participant: participantId }, { participant: secondParticipantId }];
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { assignments }), options);
+        const count = await HistoryModel.db.countDocuments({ 'history.parent': shift._id });
+        await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [...assignments].reverse() }, options);
+        expect(await HistoryModel.db.countDocuments({ 'history.parent': shift._id })).toBe(count);
+        await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [] }, options);
+        expect((await shiftsService.singleShift(plan._id, shift._id, options)).assignments).toEqual([]);
+        expect(await HistoryModel.db.countDocuments({ 'history.parent': shift._id })).toBe(count + 1);
+    });
+    it('inherits settings and supports relaxing, disabling and restoring overrides', async () => {
+        const plan = await setupPlan();
+        const input = { name: plan.name, timeZone: plan.timeZone, settingsOverrides: {
+                minimumRest: { enabled: false, minutes: 60 }, absenceEnforcement: false,
+            } };
+        const local = await plansService.changePlan(plan._id, input, options);
+        expect(local.effectiveSettings.minimumRest).toEqual({ enabled: false, minutes: 60 });
+        const company = policy();
+        company.minimumRest = { enabled: true, minutes: 720 };
+        await settingsService.changeSettings({ settings: company }, options);
+        expect((await plansService.singlePlan(plan._id, options)).effectiveSettings.minimumRest.minutes).toBe(60);
+        const inherited = await plansService.changePlan(plan._id, { ...input, settingsOverrides: {} }, options);
+        expect(inherited.effectiveSettings.minimumRest.minutes).toBe(720);
+        expect(inherited.effectiveSettings.absenceEnforcement).toBe(true);
+    });
+    it('supports complete local policies without company settings and requires policy for assigned shifts', async () => {
+        const created = await plansService.createPlan(planInput(), options);
+        await createDays(created._id, options, [{ date: day, areas: areaLinks() }, { date: nextDay, areas: areaLinks() }]);
+        const plan = (await plansService.singlePlan(created._id, options));
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).rejects.toThrow('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+        expect((await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { assignments: [] }), options)).assignments).toEqual([]);
+        const changed = await plansService.changePlan(plan._id, { ...planInput(), settingsOverrides: policy() }, options);
+        expect(changed.effectiveSettings).toEqual(policy());
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+    });
+    it('records sickness against existing schedules, blocks new assignments and permits a local override', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        const absence = await absencesService.createAbsence({ customer: customerId, type: 'sickness', start: `${day}T00:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }, options);
+        const existing = (await shiftsService.singleShift(plan._id, shift._id, options));
+        expect(existing.assignments).toHaveLength(1);
+        expect(existing.violations).toContainEqual({ customer: customerId.toHexString(), shift: shift._id.toHexString(), rule: 'absence', absence: absence._id.toHexString() });
+        expect(existing.violations.every((violation) => !('type' in violation))).toBe(true);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        const expanded = await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [
+                { participant: participantId },
+                { participant: secondParticipantId },
+            ] }, options);
+        expect(expanded.assignments).toHaveLength(2);
+        expect(expanded.violations[0].rule).toBe('absence');
+        await plansService.changePlan(plan._id, { ...planInput(), settingsOverrides: { absenceEnforcement: false } }, options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { start: `${day}T13:00:00+02:00`, end: `${day}T14:00:00+02:00` }), options);
+        await expect(absencesService.singleAbsence(absence._id, { ...options, company: 'foreign' })).resolves.toBeNull();
+        await expect(absencesService.removeAbsence(absence._id, { ...options, company: 'foreign' })).rejects.toThrow('EMPLOYEE_ABSENCE_NOT_FOUND');
+        await absencesService.changeAbsence(absence._id, { customer: customerId, type: 'vacation', start: `${nextDay}T00:00:00+02:00`, end: `${nextDay}T12:00:00+02:00` }, options);
+        expect((await absencesService.listAbsences({ customer: customerId }, options)).all).toBe(1);
+        await absencesService.removeAbsence(absence._id, options);
+        expect((await absencesService.listAbsences({}, options)).data).toEqual([]);
+        expect(await HistoryModel.db.findOne({ 'history.parent': absence._id, 'history.reason': 'delete' })).not.toBeNull();
+    });
+    it('enforces qualifying staggered breaks and calculates net day/night working time', async () => {
+        const plan = await setupPlan();
+        const enabled = policy();
+        enabled.breaks.enabled = true;
+        await settingsService.changeSettings({ settings: enabled }, options);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { end: `${day}T16:00:00+02:00` }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            end: `${day}T16:00:00+02:00`, assignments: [
+                { participant: participantId, breaks: [{ start: `${day}T12:00:00+02:00`, end: `${day}T12:30:00+02:00` }] },
+                { participant: secondParticipantId, breaks: [{ start: `${day}T12:30:00+02:00`, end: `${day}T13:00:00+02:00` }] },
+            ],
+        }), options);
+        expect(shift.workingTime[0]).toMatchObject({ daytimeMinutes: 450, nighttimeMinutes: 0, breakMinutes: 30 });
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            end: `${day}T16:00:00+02:00`, assignments: [{ participant: participantId,
+                    breaks: [{ start: `${day}T12:00:00+02:00`, end: `${day}T12:10:00+02:00` }] }],
+        }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+    });
+    it('accepts the exact work threshold but refuses a sufficiently long break taken too late', async () => {
+        const plan = await setupPlan();
+        const settings = policy();
+        settings.breaks.enabled = true;
+        await settingsService.changeSettings({ settings }, options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { end: `${day}T14:00:00+02:00` }), options);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            end: `${day}T16:00:00+02:00`, assignments: [{ participant: participantId,
+                    breaks: [{ start: `${day}T15:00:00+02:00`, end: `${day}T15:30:00+02:00` }] }],
+        }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+    });
+    it('splits overnight work at day/night boundaries and excludes actual breaks', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            start: `${day}T21:30:00+02:00`, end: `${nextDay}T06:30:00+02:00`,
+            assignments: [{ participant: participantId,
+                    breaks: [{ start: `${nextDay}T01:00:00+02:00`, end: `${nextDay}T01:30:00+02:00` }] }],
+        }), options);
+        expect(shift.workingTime[0]).toMatchObject({ daytimeMinutes: 60, nighttimeMinutes: 450, breakMinutes: 30 });
+    });
+    it.each([
+        [{ start: `${day}T07:00:00+02:00`, end: `${day}T08:30:00+02:00` }],
+        [{ start: `${day}T10:00:00+02:00`, end: `${day}T10:30:00+02:00` }, { start: `${day}T10:15:00+02:00`, end: `${day}T11:00:00+02:00` }],
+    ])('refuses breaks outside the shift or overlapping', async (...breaks) => {
+        const plan = await setupPlan();
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            assignments: [{ participant: participantId, breaks }],
+        }), options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it('rejects impossible policy partitions and unordered thresholds without modifying stored settings', async () => {
+        await setupPlan();
+        const invalidPartition = policy();
+        invalidPartition.daytime.start = '07:00';
+        await expect(settingsService.changeSettings({ settings: invalidPartition }, options)).rejects.toThrow('VALIDATION_FAILED');
+        const invalidThresholds = policy();
+        invalidThresholds.breaks.requirements = [
+            { afterWorkMinutes: 540, minimumTotalBreakMinutes: 45 }, { afterWorkMinutes: 360, minimumTotalBreakMinutes: 30 },
+        ];
+        await expect(settingsService.changeSettings({ settings: invalidThresholds }, options)).rejects.toThrow('VALIDATION_FAILED');
+        expect((await settingsService.singleSettings(options)).settings).toEqual(policy());
+    });
+    it('reports inherited policy incompatibility after a company change without losing assignments', async () => {
+        const plan = await setupPlan();
+        await plansService.changePlan(plan._id, { ...planInput(), settingsOverrides: { daytime: policy().daytime } }, options);
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        const settings = policy();
+        settings.daytime = { start: '07:00', end: '23:00' };
+        settings.nighttime = { start: '23:00', end: '07:00' };
+        await settingsService.changeSettings({ settings }, options);
+        expect((await plansService.singlePlan(plan._id, options)).effectiveSettings).toBeNull();
+        const attention = (await shiftsService.singleShift(plan._id, shift._id, options));
+        expect(attention.assignments).toHaveLength(1);
+        expect(attention.violations[0].rule).toBe('settingsMissing');
+    });
+    it('returns an empty member envelope for orphaned references instead of inflated totals', async () => {
+        const plan = await setupPlan();
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        await ListsModel.db.deleteOne({ _id: listId });
+        expect(await shiftsService.myShifts(customerId, {}, { ...options, user: 'anna-account', app: 'members' }))
+            .toEqual({ data: [], all: 0, count: 0, sites: { first: 0, current: 0, last: 0, range: [0, 0] } });
+    });
+    it.each([
+        { start: '2026-02-30T08:00:00+02:00', end: '2026-03-01T12:00:00+02:00' },
+        { start: `${day}T12:00:00+02:00`, end: `${day}T08:00:00+02:00` },
+        { requiredPeople: -1 },
+        { matchingPeople: 1.5 },
+        { structures: [{ structure: '507f1f77bcf86cd799439011', constraint: 'bogus' }] },
+        { structures: [{ structure: '507f1f77bcf86cd799439011', constraint: 'required', value: {} }] },
+        { structures: [{ structure: 'x'.repeat(25), constraint: 'required' }] },
+    ])('rejects invalid shift schema/domain inputs %j', async (changes) => {
+        const plan = await setupPlan();
+        await expect(shiftsService.createShift(plan._id, { ...shiftInput(plan, planAreas(plan)[0].area), ...changes }, options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it.each([
+        { date: '2026-03-29', start: '2026-03-29T00:00:00+01:00', end: '2026-03-29T06:00:00+02:00', minutes: 300 },
+        { date: '2026-10-25', start: '2026-10-25T00:00:00+02:00', end: '2026-10-25T06:00:00+01:00', minutes: 420 },
+    ])('calculates actual nighttime through DST on $date', async ({ date, start, end, minutes }) => {
+        await settingsService.changeSettings({ settings: policy() }, options);
+        const created = await plansService.createPlan(planInput(listId), options);
+        await createDays(created._id, options, [{ date, areas: areaLinks() }]);
+        const plan = (await plansService.singlePlan(created._id, options));
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { day: date, start, end }), options);
+        expect(shift.workingTime[0]).toMatchObject({ daytimeMinutes: 0, nighttimeMinutes: minutes });
+    });
+    it('counts overnight work on both days for consecutive-day enforcement', async () => {
+        const plan = await setupPlan();
+        const enabled = policy();
+        enabled.maximumConsecutiveWorkingDays = { enabled: true, days: 1 };
+        await settingsService.changeSettings({ settings: enabled }, options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { start: `${day}T22:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }), options);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            start: `${day}T22:00:00+02:00`, end: `${nextDay}T01:00:00+02:00`,
+        }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+    });
+    it('checks consecutive work across projects and allows the incoming plan to relax the project rule', async () => {
+        const plan = await setupPlan();
+        const settings = policy();
+        settings.maximumConsecutiveWorkingDays = { enabled: true, days: 1 };
+        await settingsService.changeSettings({ settings }, options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        const otherListId = new ObjectId();
+        const otherParticipantId = new ObjectId();
+        const otherOptions = { ...options, project: 'other-project' };
+        await settingsService.changeSettings({ settings }, otherOptions);
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+        await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, list: otherListId, project: otherOptions.project });
+        const otherPlan = await otherProjectPlan(otherListId, otherOptions);
+        const next = shiftInput(otherPlan, planAreas(otherPlan)[0].area, { day: nextDay, assignments: [{ participant: otherParticipantId }] });
+        await expect(shiftsService.createShift(otherPlan._id, next, otherOptions)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        await plansService.changePlan(otherPlan._id, { ...planInput(otherListId),
+            settingsOverrides: { maximumConsecutiveWorkingDays: { enabled: true, days: 2 } },
+        }, otherOptions);
+        expect((await shiftsService.createShift(otherPlan._id, next, otherOptions)).violations).toEqual([]);
+    });
+    it('enforces a maximum daily working time per person and lets a plan override it', async () => {
+        const plan = await setupPlan();
+        const area = planAreas(plan)[0].area;
+        const settings = policy();
+        settings.maximumDailyWorkMinutes = { enabled: true, minutes: 300 };
+        await settingsService.changeSettings({ settings }, options);
+        const morning = await shiftsService.createShift(plan._id, shiftInput(plan, area), options);
+        expect(morning.violations).toEqual([]);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T16:00:00+02:00`, end: `${day}T18:00:00+02:00`,
+        }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        // A long break removes the minutes from the daily total, so the same span stays within the limit.
+        const reduced = await shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T16:00:00+02:00`, end: `${day}T18:00:00+02:00`,
+            assignments: [{ participant: participantId, breaks: [{ start: `${day}T16:00:00+02:00`, end: `${day}T17:00:00+02:00` }] }],
+        }), options);
+        expect(reduced.violations).toEqual([]);
+        await plansService.changePlan(plan._id, { ...planInput(), settingsOverrides: { maximumDailyWorkMinutes: { enabled: true, minutes: 600 } } }, options);
+        expect((await shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T18:00:00+02:00`, end: `${day}T19:00:00+02:00`,
+        }), options)).violations).toEqual([]);
+    });
+    it('refuses foreign-company customer references for assignments and absences', async () => {
+        const plan = await setupPlan();
+        await CustomersModel.db.updateOne({ _id: customerId }, { $set: { company: 'foreign' } });
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(absencesService.createAbsence({ customer: customerId, type: 'vacation', start: `${day}T00:00:00Z`, end: `${nextDay}T00:00:00Z` }, options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it('protects referenced areas/days and timezone changes; shift edits retain assignments', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { start: `${day}T00:30:00+02:00`, end: `${day}T04:00:00+02:00` }), options);
+        const config = { ...planInput(), settingsOverrides: {} };
+        await expect(daysService.changeDay(plan._id, dayId(plan, day), { date: day, areas: [planAreas(plan)[1]] }, options)).rejects.toThrow('SHIFT_PLAN_REFERENCES_IN_USE');
+        await expect(daysService.removeDay(plan._id, dayId(plan, day), options)).rejects.toThrow('SHIFT_PLAN_DAY_IN_USE');
+        await expect(plansService.changePlan(plan._id, { ...config, timeZone: 'UTC' }, options)).rejects.toThrow('SHIFT_PLAN_REFERENCES_IN_USE');
+        const changed = await shiftsService.changeShift(plan._id, shift._id, { area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Changed', start: `${day}T01:00:00+02:00`, end: `${day}T04:00:00+02:00` }, options);
+        expect(changed.assignments).toHaveLength(1);
+        expect(changed.title).toBe('Changed');
+        await shiftsService.removeShift(plan._id, shift._id, options);
+        expect(await shiftsService.singleShift(plan._id, shift._id, options)).toBeNull();
+        expect(await HistoryModel.db.findOne({ 'history.parent': shift._id, 'history.reason': 'delete' })).not.toBeNull();
+    });
+    it('filters overlapping intervals, assignment areas and pagination with inclusive/exclusive boundaries', async () => {
+        const plan = await setupPlan();
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[1].area, { start: `${day}T12:00:00+02:00`, end: `${day}T16:00:00+02:00` }), options);
+        const result = await shiftsService.listShifts(plan._id, { from: `${day}T12:00:00+02:00`, to: `${day}T16:00:00+02:00`, area: planAreas(plan)[1].area }, options);
+        expect(result).toMatchObject({ all: 1, count: 1, sites: { first: 1, current: 1, last: 1, range: [1, 1] } });
+        expect(result.data[0].start).toBe(`${day}T10:00:00.000Z`);
+        expect((await shiftsService.listShifts(plan._id, { site: 3 }, options)).data).toEqual([]);
+        await expect(shiftsService.listShifts(plan._id, { site: 0 }, options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(shiftsService.listShifts(plan._id, { from: `${day}T12:00:00Z`, to: `${day}T12:00:00Z` }, options)).rejects.toThrow('VALIDATION_FAILED');
+        await expect(plansService.singlePlan(plan._id, { ...options, company: 'foreign' })).resolves.toBeNull();
+        await expect(shiftsService.changeShift(plan._id, new ObjectId(), { area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Missing', start: `${day}T12:00:00Z`, end: `${day}T13:00:00Z` }, options)).rejects.toThrow('SHIFT_NOT_FOUND');
+    });
+    it('rejects cross-project double booking and enforces the upcoming plan rest policy even when editing an earlier shift', async () => {
+        const plan = await setupPlan();
+        const otherListId = new ObjectId();
+        const otherParticipantId = new ObjectId();
+        const otherOptions = { ...options, project: 'other-project' };
+        await settingsService.changeSettings({ settings: policy() }, otherOptions);
+        await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+        await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, project: otherOptions.project, list: otherListId });
+        const otherPlan = await otherProjectPlan(otherListId, otherOptions, { minimumRest: { enabled: true, minutes: 660 } });
+        const earlier = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        const later = await shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+            day: nextDay, title: 'Next morning', assignments: [{ participant: otherParticipantId }],
+        }), otherOptions);
+        await expect(shiftsService.changeShift(plan._id, earlier._id, {
+            area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Late', start: `${day}T08:00:00+02:00`, end: `${day}T23:00:00+02:00`,
+        }, options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        await plansService.changePlan(otherPlan._id, {
+            ...planInput(otherListId), settingsOverrides: { minimumRest: { enabled: true, minutes: 540 } },
+        }, otherOptions);
+        await shiftsService.changeShift(plan._id, earlier._id, {
+            area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Late', start: `${day}T08:00:00+02:00`, end: `${day}T23:00:00+02:00`,
+        }, options);
+        await expect(shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+            title: 'Overlap', start: `${day}T10:00:00+02:00`, end: `${day}T12:00:00+02:00`, assignments: [{ participant: otherParticipantId }],
+        }), otherOptions)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        expect((await shiftsService.singleShift(otherPlan._id, later._id, otherOptions)).violations).toEqual([]);
+        await absencesService.createAbsence({ customer: customerId, type: 'vacation', start: `${nextDay}T00:00:00Z`, end: `${nextDay}T23:00:00Z` }, otherOptions);
+        expect((await shiftsService.singleShift(otherPlan._id, later._id, otherOptions)).violations[0].rule).toBe('absence');
+    });
+    it('reads a plan without pulling in a sibling plan\'s overlapping shifts', async () => {
+        const plan = await setupPlan();
+        const siblingPlan = await setupPlan();
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area), options);
+        const siblingDay = siblingPlan.days.find((entry) => entry.date === day);
+        await ShiftModel.db.insertOne({
+            _id: new ObjectId(), company: options.company, project: options.project, plan: siblingPlan._id,
+            day: siblingDay._id, area: planAreas(siblingPlan)[0].area, list: listId, title: 'Sibling',
+            start: `${day}T10:00:00+02:00`, end: `${day}T14:00:00+02:00`,
+            assignments: [{ participant: participantId, customer: customerId, breaks: [] }],
+        });
+        expect((await shiftsService.listShifts(plan._id, {}, options)).data[0].violations).toEqual([]);
+        expect((await shiftsService.listShifts(siblingPlan._id, {}, options)).data[0].violations).toEqual([]);
+    });
+    it('attaches participant structure answers and definitions to reported shifts', async () => {
+        const plan = await setupPlan();
+        const structureId = new ObjectId();
+        await StructureModel.db.insertOne({
+            _id: structureId, id: 's-string-1', model: 'listsParticipants', company: options.company, project: options.project,
+            type: 'string', question: 'Color', max: 20,
+        });
+        await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { 's-string-1': 'blue' } });
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            structures: [{ structure: structureId.toHexString(), constraint: 'required', value: 'blue' }],
+        }), options);
+        const assigned = shift.participants[0];
+        expect(assigned.structures).toEqual([expect.objectContaining({ id: 's-string-1' })]);
+        expect(assigned['s-string-1']).toBe('blue');
+        expect(assigned.user?.structures).toEqual([]);
+    });
+    it('rejects booking one person into overlapping shifts while allowing adjacency and other people', async () => {
+        const plan = await setupPlan();
+        const area = planAreas(plan)[0].area;
+        const morning = await shiftsService.createShift(plan._id, shiftInput(plan, area), options);
+        expect(morning.violations).toEqual([]);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T10:00:00+02:00`, end: `${day}T14:00:00+02:00`,
+        }), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        const adjacent = await shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T12:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+        }), options);
+        expect(adjacent.violations).toEqual([]);
+        const other = await shiftsService.createShift(plan._id, shiftInput(plan, area, {
+            start: `${day}T10:00:00+02:00`, end: `${day}T14:00:00+02:00`, assignments: [{ participant: secondParticipantId }],
+        }), options);
+        expect(other.violations).toEqual([]);
+        await expect(shiftsService.changeShift(plan._id, adjacent._id, {
+            area, day: dayId(plan, day), title: adjacent.title, start: `${day}T11:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+        }, options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+    });
+    it('rejects worsening an existing rest violation but allows improving it after settings changed', async () => {
+        const plan = await setupPlan();
+        const earlier = await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, { end: `${day}T20:00:00+02:00` }), options);
+        await shiftsService.createShift(plan._id, shiftInput(plan, planAreas(plan)[0].area, {
+            day: nextDay, start: `${nextDay}T08:00:00+02:00`, end: `${nextDay}T12:00:00+02:00`,
+        }), options);
+        const settings = policy();
+        settings.minimumRest = { enabled: true, minutes: 840 };
+        await settingsService.changeSettings({ settings }, options);
+        await expect(shiftsService.changeShift(plan._id, earlier._id, {
+            area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Worse', start: `${day}T08:00:00+02:00`, end: `${day}T21:00:00+02:00`,
+        }, options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+        const improved = await shiftsService.changeShift(plan._id, earlier._id, {
+            area: planAreas(plan)[0].area, day: dayId(plan, day), title: 'Improved', start: `${day}T08:00:00+02:00`, end: `${day}T19:00:00+02:00`,
+        }, options);
+        expect(improved.end).toBe(`${day}T17:00:00.000Z`);
+    });
+    it('creates, searches, replaces and deletes independent areas with scoped history', async () => {
+        const area = await areasService.createWorkArea({ id: 'wa-kitchen-a', name: 'Kitchen [A]', description: 'Old', location: 'Floor 1', address: { city: 'Berlin', country: 'DE' }, structures: [{ structure: '507f1f77bcf86cd799439011', constraint: 'required' }] }, options);
+        await areasService.createWorkArea({ name: 'Kitchen [A]' }, options);
+        const page = await areasService.listWorkAreas({ search: '[A]' }, options);
+        expect(page).toMatchObject({ all: 2, count: 2, sites: { first: 1, current: 1, last: 1, range: [1, 2] } });
+        expect(area._id).toBeInstanceOf(ObjectId);
+        expect(area.id).toBe('wa-kitchen-a');
+        expect(area.structures).toEqual([{ structure: '507f1f77bcf86cd799439011', constraint: 'required' }]);
+        expect(area).not.toHaveProperty('categoryIds');
+        expect(await areasService.singleWorkArea(area._id, { ...options, project: 'foreign' })).toBeNull();
+        await expect(areasService.changeWorkArea(area._id, { name: 'Foreign edit' }, { ...options, company: 'foreign' })).rejects.toThrow('WORK_AREA_NOT_FOUND');
+        const updated = await areasService.changeWorkArea(area._id, { name: 'Kitchen B', description: '', address: {} }, options);
+        expect(updated.id).toBe('wa-kitchen-a');
+        expect(updated).not.toHaveProperty('structures');
+        expect(updated).not.toHaveProperty('description');
+        expect(updated).not.toHaveProperty('location');
+        expect(updated).not.toHaveProperty('address');
+        expect(updated._id.equals(area._id)).toBe(true);
+        const restructured = await areasService.changeWorkArea(area._id, { name: 'Kitchen C', structures: [{ structure: '507f1f77bcf86cd799439011', constraint: 'required' }, { structure: '507f1f77bcf86cd799439012', constraint: 'forbidden', value: 'option-b' }] }, options);
+        expect(restructured.structures).toEqual([{ structure: '507f1f77bcf86cd799439011', constraint: 'required' }, { structure: '507f1f77bcf86cd799439012', constraint: 'forbidden', value: 'option-b' }]);
+        const history = await HistoryModel.db.findOne({ 'history.parent': area._id, 'history.reason': 'change' });
+        expect(history).toMatchObject({ name: 'Kitchen B', history: { model: 'workAreas', user: options.user } });
+        await areasService.removeWorkArea(area._id, options);
+        expect(await areasService.singleWorkArea(area._id, options)).toBeNull();
+        expect(await HistoryModel.db.findOne({ 'history.parent': area._id, 'history.reason': 'delete' })).not.toBeNull();
+    });
+    it.each([
+        { address: { private: 'value' } }, { name: '' }, { structures: [{ structure: '507f1f77bcf86cd799439011', constraint: 'bogus' }] },
+    ])('rejects invalid area metadata: %j', async (changes) => {
+        await expect(areasService.createWorkArea({ name: 'Kitchen', ...changes }, options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await AreaModel.db.countDocuments({})).toBe(2);
+    });
+    it('protects area deletion across all plans and permits plan-specific unlinking', async () => {
+        const first = await setupPlan();
+        const second = await plansService.createPlan(planInput(listId, { name: 'Events' }), options);
+        await createDays(second._id, options, [{ date: day, areas: areaLinks() }, { date: nextDay, areas: areaLinks() }]);
+        const secondRead = (await plansService.singlePlan(second._id, options));
+        const receptionLink = planAreas(first)[1];
+        await expect(areasService.removeWorkArea(housekeepingAreaId, options)).rejects.toThrow('WORK_AREA_IN_USE');
+        await daysService.changeDay(first._id, dayId(first, day), { date: day, areas: [receptionLink] }, options);
+        await daysService.changeDay(first._id, dayId(first, nextDay), { date: nextDay, areas: [receptionLink] }, options);
+        expect(planAreas(secondRead)[0].area.equals(housekeepingAreaId)).toBe(true);
+        await expect(areasService.removeWorkArea(housekeepingAreaId, options)).rejects.toThrow('WORK_AREA_IN_USE');
+        await daysService.changeDay(second._id, dayId(secondRead, day), { date: day, areas: [planAreas(secondRead)[1]] }, options);
+        await daysService.changeDay(second._id, dayId(secondRead, nextDay), { date: nextDay, areas: [planAreas(secondRead)[1]] }, options);
+        await areasService.removeWorkArea(housekeepingAreaId, options);
+        expect(await areasService.singleWorkArea(housekeepingAreaId, options)).toBeNull();
+    });
+    it('checks assignment references independently of plan links before deleting an area', async () => {
+        const plan = await setupPlan();
+        await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId), options);
+        // Simulate an externally damaged day: area deletion still protects the persisted assignment.
+        await DayModel.db.updateOne({ plan: plan._id, date: day }, { $set: { areas: [] } });
+        await expect(areasService.removeWorkArea(housekeepingAreaId, options)).rejects.toThrow('WORK_AREA_IN_USE');
+    });
+    it('shares area identity across weekly plans and reflects metadata changes in plans and member reads', async () => {
+        const first = await setupPlan();
+        const created = await plansService.createPlan(planInput(listId), options);
+        await createDays(created._id, options, [{ date: '2026-10-12', areas: areaLinks() }]);
+        const second = (await plansService.singlePlan(created._id, options));
+        await shiftsService.createShift(first._id, shiftInput(first, housekeepingAreaId), options);
+        await areasService.changeWorkArea(housekeepingAreaId, { name: 'Shared housekeeping', location: 'West wing' }, options);
+        const firstRead = (await plansService.singlePlan(first._id, options));
+        const secondRead = (await plansService.singlePlan(second._id, options));
+        expect(firstRead.workAreas[0].name).toBe('Shared housekeeping');
+        expect(secondRead.workAreas[0].name).toBe('Shared housekeeping');
+        expect(await AreaModel.db.countDocuments({})).toBe(2);
+        const member = await shiftsService.myShifts(customerId, {}, { ...options, user: 'anna-account', app: 'members' });
+        expect(member.data[0].area.name).toBe('Shared housekeeping');
+        expect(member.data[0].area).not.toHaveProperty('company');
+        expect(member.data[0].area).not.toHaveProperty('project');
+    });
+    it('searches plans by name while escaping regex metacharacters', async () => {
+        await setupPlan();
+        await plansService.createPlan(planInput(listId, { name: 'Events [October]' }), options);
+        const matched = await plansService.listPlans({ search: 'events' }, options);
+        expect(matched.all).toBe(1);
+        expect(matched.data[0].name).toBe('Events [October]');
+        const escaped = await plansService.listPlans({ search: '[October]' }, options);
+        expect(escaped.all).toBe(1);
+        expect((await plansService.listPlans({ search: 'missing' }, options)).all).toBe(0);
+    });
+    it('lists weekly plans by planning dates and keeps both bounds on the same day', async () => {
+        const first = await setupPlan();
+        const futureCreated = await plansService.createPlan(planInput(listId), options);
+        await createDays(futureCreated._id, options, [{ date: '2026-10-12', areas: areaLinks() }]);
+        const disjointCreated = await plansService.createPlan(planInput(listId), options);
+        await createDays(disjointCreated._id, options, [{ date: '2026-10-01', areas: areaLinks() }, { date: '2026-10-20', areas: areaLinks() }]);
+        // mongo-mock has no distinct implementation; reproduce the day-date range query over the stored day documents.
+        const storedDays = await DayModel.db.find({ company: options.company, project: options.project }).toArray();
+        const distinctSpy = jest.spyOn(DayModel.db, 'distinct').mockImplementation((async (_field, filter) => {
+            const range = (filter.date ?? {});
+            const plans = storedDays
+                .filter((entry) => (!range.$gte || entry.date >= range.$gte) && (!range.$lt || entry.date < range.$lt))
+                .map((entry) => entry.plan.toHexString());
+            return [...new Set(plans)].map((hex) => new ObjectId(hex));
+        }));
+        try {
+            const filtered = await plansService.listPlans({ list: listId, from: '2026-10-10', to: '2026-10-15' }, options);
+            expect(filtered.all).toBe(1);
+            expect(filtered.data[0]._id.equals(futureCreated._id)).toBe(true);
+            const ordered = await plansService.listPlans({ list: listId, from: day, to: '2026-10-13' }, options);
+            expect(ordered.all).toBe(2);
+            expect(ordered.data[0]._id.equals(first._id)).toBe(true);
+            await expect(plansService.listPlans({ list: listId, from: day, to: day }, options)).rejects.toThrow('VALIDATION_FAILED');
+            expect(await plansService.singlePlan(new ObjectId(), options)).toBeNull();
+        }
+        finally {
+            distinctSpy.mockRestore();
+        }
+    });
+    it('permits overlapping departments in one area while keeping shift operations bound to their plan', async () => {
+        const restaurant = await setupPlan();
+        const eventsCreated = await plansService.createPlan(planInput(listId, { name: 'Events' }), options);
+        await createDays(eventsCreated._id, options, [{ date: day, areas: areaLinks() }, { date: nextDay, areas: areaLinks() }]);
+        const events = (await plansService.singlePlan(eventsCreated._id, options));
+        const restaurantShift = await shiftsService.createShift(restaurant._id, shiftInput(restaurant, housekeepingAreaId), options);
+        const eventsShift = await shiftsService.createShift(events._id, shiftInput(events, housekeepingAreaId, {
+            assignments: [{ participant: secondParticipantId }],
+        }), options);
+        expect(eventsShift.violations).toEqual([]);
+        expect(await shiftsService.singleShift(events._id, restaurantShift._id, options)).toBeNull();
+        await expect(shiftsService.removeShift(events._id, restaurantShift._id, options)).rejects.toThrow('SHIFT_NOT_FOUND');
+        expect((await shiftsService.listShifts(restaurant._id, {}, options)).all).toBe(1);
+        await expect(shiftsService.createShift(events._id, shiftInput(events, housekeepingAreaId), options)).rejects.toThrow('SHIFT_PLANNING_RULE_VIOLATION');
+    });
+    it('keeps work area category bindings specific to each plan employee list', async () => {
+        const original = await setupPlan();
+        const departmentList = new ObjectId();
+        const departmentCategory = new ObjectId();
+        await ListsModel.db.insertOne({ ...list, _id: departmentList, categories: [{ _id: departmentCategory, id: 'events', name: 'Events' }] });
+        const eventsCreated = await plansService.createPlan(planInput(departmentList), options);
+        await createDays(eventsCreated._id, options, [
+            { date: day, areas: [{ area: housekeepingAreaId }] },
+            { date: nextDay, areas: [{ area: housekeepingAreaId }] },
+        ]);
+        const events = await plansService.changePlan(eventsCreated._id, planInput(departmentList, { workAreaCategories: [{ area: housekeepingAreaId, categoryIds: [departmentCategory] }] }), options);
+        expect(planAreas(events)[0].area.equals(planAreas(original)[0].area)).toBe(true);
+        expect(events.workAreaCategories[0].categoryIds[0].equals(departmentCategory)).toBe(true);
+        expect(original.workAreaCategories).toBeUndefined();
+        await expect(plansService.changePlan(events._id, planInput(departmentList, { workAreaCategories: [{ area: housekeepingAreaId, categoryIds: [categoryId] }] }), options)).rejects.toThrow('VALIDATION_FAILED');
+    });
+    it('rejects foreign-project or unlinked area identities', async () => {
+        const plan = await setupPlan();
+        const foreign = await areasService.createWorkArea({ name: 'Foreign area' }, { ...options, project: 'other-project' });
+        await expect(daysService.createDay(plan._id, { date: '2026-10-15', areas: [{ area: foreign._id }] }, options)).rejects.toThrow('VALIDATION_FAILED');
+        const unlinked = await areasService.createWorkArea({ name: 'Unused area' }, options);
+        await expect(shiftsService.createShift(plan._id, shiftInput(plan, unlinked._id), options)).rejects.toThrow('VALIDATION_FAILED');
+        expect(await AreaModel.db.countDocuments({ company: options.company, project: options.project })).toBe(3);
+    });
+    it('treats normalized break instants and input property order as an assignment no-op', async () => {
+        const plan = await setupPlan();
+        const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+            assignments: [{ participant: participantId, breaks: [{ start: `${day}T10:00:00+02:00`, end: `${day}T10:30:00+02:00` }] }],
+        }), options);
+        const count = await HistoryModel.db.countDocuments({ 'history.parent': shift._id });
+        await shiftsService.replaceAssignments(plan._id, shift._id, { assignments: [{ participant: participantId,
+                    breaks: [{ end: `${day}T08:30:00Z`, start: `${day}T08:00:00Z` }],
+                }] }, options);
+        expect(await HistoryModel.db.countDocuments({ 'history.parent': shift._id })).toBe(count);
+    });
+    describe('read-only shift autofill', () => {
+        async function setupAutofill(changes = {}) {
+            const plan = await setupPlan();
+            const structureId = new ObjectId();
+            await StructureModel.db.insertOne({ _id: structureId, company: options.company, project: options.project,
+                model: 'listsParticipants', id: 's-boolean-preferred', type: 'boolean', question: 'Preferred' });
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { 's-boolean-preferred': true } });
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 1,
+                structures: [{ structure: structureId.toHexString(), grade: 'very-positive' }], ...changes,
+            }), options);
+            return { plan, shift, structureId };
+        }
+        it('ranks suggestions deterministically, batches rule reads and changes no stored documents', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2 });
+            const before = await Promise.all(models.map(async (model) => JSON.stringify(await model.db.find({}).sort({ _id: 1 }).toArray())));
+            const settingsRead = jest.spyOn(settingsService, 'singleSettings');
+            const absencesRead = jest.spyOn(absencesService, 'absencesForPlanning');
+            try {
+                const expected = { shift: shift._id, users: [secondParticipantId, participantId] };
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual(expected);
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual(expected);
+                expect(settingsRead).toHaveBeenCalledTimes(2);
+                expect(absencesRead).toHaveBeenCalledTimes(2);
+                const after = await Promise.all(models.map(async (model) => JSON.stringify(await model.db.find({}).sort({ _id: 1 }).toArray())));
+                expect(after).toEqual(before);
+            }
+            finally {
+                settingsRead.mockRestore();
+                absencesRead.mockRestore();
+            }
+        });
+        it('keeps current assignments and only fills the remaining places', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: participantId }] });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId, secondParticipantId] });
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual(shift.assignments);
+        });
+        it('retains existing attention items without allowing new violations', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: participantId }] });
+            await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state: 'canceled' } });
+            await absencesService.createAbsence({ customer: customerId, type: 'sickness', start: `${day}T00:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId, secondParticipantId] });
+        });
+        it.each([undefined, 0, 1])('keeps an already assigned shift unchanged with target %p', async (requiredPeople) => {
+            const { plan, shift } = await setupAutofill({ requiredPeople, assignments: [{ participant: participantId }] });
+            const candidateRead = jest.spyOn(participantsService, 'planningParticipants');
+            try {
+                expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+                expect(candidateRead).not.toHaveBeenCalled();
+            }
+            finally {
+                candidateRead.mockRestore();
+            }
+        });
+        it('selects one list entry per person and returns a partial fill when the pool runs out', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 3 });
+            const duplicateParticipantId = new ObjectId();
+            await ParticipantsModel.db.insertOne({ ...participant, _id: duplicateParticipantId, 's-boolean-preferred': true });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId, duplicateParticipantId] });
+        });
+        it.each(['blocked', 'unchecked', 'notuseful', 'canceled'])('excludes a high-scoring %s person', async (state) => {
+            const { plan, shift } = await setupAutofill();
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { state } });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('ignores entries without a person in the company', async () => {
+            const { plan, shift } = await setupAutofill();
+            await CustomersModel.db.updateOne({ _id: secondCustomerId }, { $set: { company: 'foreign' } });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('applies the plan default state and area-category binding together', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 3 });
+            const eventsCategoryId = new ObjectId();
+            const reservedCustomerId = new ObjectId();
+            const reservedParticipantId = new ObjectId();
+            await ListsModel.db.updateOne({ _id: listId }, { $set: { categories: [
+                        ...list.categories, { _id: eventsCategoryId, id: 'events', name: 'Events' },
+                    ] } });
+            await ParticipantsModel.db.updateOne({ _id: secondParticipantId }, { $set: { state: 'reserved', category: 'events' } });
+            await CustomersModel.db.insertOne({ ...customer, _id: reservedCustomerId, id: 'reserved', accounts: [] });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: reservedParticipantId, user: reservedCustomerId, state: 'reserved' });
+            await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'reserved',
+                workAreaCategories: [{ area: housekeepingAreaId, categoryIds: [categoryId] }],
+            }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [reservedParticipantId] });
+        });
+        it('ignores matchingPeople and fills only to requiredPeople', async () => {
+            const { plan, shift, structureId } = await setupAutofill({ requiredPeople: 2, matchingPeople: 2 });
+            await ShiftModel.db.updateOne({ _id: shift._id }, { $set: { structures: [
+                        { structure: structureId.toHexString(), constraint: 'required', value: true, grade: 'very-negative' },
+                    ] } });
+            // matchingPeople is a coverage concern only; autofill uses the ranked pool up to requiredPeople.
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id,
+                users: [secondParticipantId, participantId],
+            });
+        });
+        it('counts a retained assignment outside the candidate filter', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2, assignments: [{ participant: secondParticipantId }] });
+            await ParticipantsModel.db.updateOne({ _id: participantId }, { $set: { state: 'reserved' } });
+            await plansService.changePlan(plan._id, planInput(listId, { defaultParticipantState: 'reserved' }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId, participantId] });
+        });
+        it('does not reject matchingPeople above requiredPeople', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 1, matchingPeople: 2 });
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+        });
+        it('skips an overlapping high-scoring person instead of double booking', async () => {
+            const { plan, shift } = await setupAutofill();
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, { assignments: [{ participant: secondParticipantId }] }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it.each([true, false])('respects absence enforcement with plan override %p', async (absenceEnforcement) => {
+            const { plan, shift } = await setupAutofill();
+            await absencesService.createAbsence({ customer: secondCustomerId, type: 'sickness', start: `${day}T00:00:00+02:00`, end: `${nextDay}T00:00:00+02:00` }, options);
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: { absenceEnforcement } }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id,
+                users: [absenceEnforcement ? participantId : secondParticipantId],
+            });
+        });
+        it.each(['rest', 'dailyHours', 'consecutiveDays'])('enforces the general %s rule', async (rule) => {
+            const { plan, shift } = await setupAutofill(rule === 'consecutiveDays'
+                ? { day: nextDay, start: `${nextDay}T08:00:00+02:00`, end: `${nextDay}T12:00:00+02:00` } : {});
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [{ participant: secondParticipantId }],
+                ...(rule === 'consecutiveDays' ? {} : { start: `${day}T00:00:00+02:00`, end: `${day}T04:00:00+02:00` }),
+            }), options);
+            const settings = policy();
+            if (rule === 'rest')
+                settings.minimumRest = { enabled: true, minutes: 660 };
+            if (rule === 'dailyHours')
+                settings.maximumDailyWorkMinutes = { enabled: true, minutes: 420 };
+            if (rule === 'consecutiveDays')
+                settings.maximumConsecutiveWorkingDays = { enabled: true, days: 1 };
+            await settingsService.changeSettings({ settings }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('uses a plan override to relax the general daily hours limit', async () => {
+            const { plan, shift } = await setupAutofill();
+            await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [{ participant: secondParticipantId }], start: `${day}T00:00:00+02:00`, end: `${day}T04:00:00+02:00`,
+            }), options);
+            const settings = policy();
+            settings.maximumDailyWorkMinutes = { enabled: true, minutes: 420 };
+            await settingsService.changeSettings({ settings }, options);
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: { maximumDailyWorkMinutes: { enabled: false, minutes: 420 } } }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+        });
+        it('protects a future shift governed by another project plan rest override', async () => {
+            const { plan, shift } = await setupAutofill({ start: `${day}T20:00:00+02:00`, end: `${day}T23:00:00+02:00` });
+            const otherListId = new ObjectId();
+            const otherParticipantId = new ObjectId();
+            const otherOptions = { ...options, project: 'other-project' };
+            await settingsService.changeSettings({ settings: policy() }, otherOptions);
+            await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, user: secondCustomerId, project: otherOptions.project, list: otherListId });
+            const otherPlan = await otherProjectPlan(otherListId, otherOptions, { minimumRest: { enabled: true, minutes: 660 } });
+            await shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+                day: nextDay, assignments: [{ participant: otherParticipantId }],
+            }), otherOptions);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('requires a valid shared break template when break rules demand it', async () => {
+            const { plan, shift } = await setupAutofill({ end: `${day}T16:00:00+02:00` });
+            const settings = policy();
+            settings.breaks.enabled = true;
+            await settingsService.changeSettings({ settings }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [] });
+            const breaks = [{ start: `${day}T12:00:00+02:00`, end: `${day}T12:30:00+02:00` }];
+            const originalBreaks = JSON.stringify(breaks);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options, breaks)).toStrictEqual({ shift: shift._id, users: [secondParticipantId] });
+            expect(JSON.stringify(breaks)).toBe(originalBreaks);
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual([]);
+            await expect(shiftsService.autofillShift(plan._id, shift._id, options, [{ start: `${day}T07:00:00+02:00`, end: `${day}T08:00:00+02:00` }])).rejects.toThrow('VALIDATION_FAILED');
+        });
+        it('requires effective settings but accepts complete plan overrides without general settings', async () => {
+            const created = await plansService.createPlan(planInput(), options);
+            await createDays(created._id, options, [{ date: day, areas: areaLinks() }]);
+            const plan = (await plansService.singlePlan(created._id, options));
+            const shift = await shiftsService.createShift(plan._id, {
+                day: dayId(plan, day), area: housekeepingAreaId, title: 'Empty', start: `${day}T08:00:00+02:00`, end: `${day}T12:00:00+02:00`,
+                requiredPeople: 1, assignments: [],
+            }, options);
+            await expect(shiftsService.autofillShift(plan._id, shift._id, options)).rejects.toThrow('SHIFT_PLANNING_SETTINGS_NOT_CONFIGURED');
+            await plansService.changePlan(plan._id, planInput(listId, { settingsOverrides: policy() }), options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [participantId] });
+        });
+        it('uses the current plan list rather than a stale shift list', async () => {
+            const { plan, shift } = await setupAutofill();
+            await plansService.changePlan(plan._id, { ...planInput(), list: undefined }, options);
+            expect(await shiftsService.autofillShift(plan._id, shift._id, options)).toStrictEqual({ shift: shift._id, users: [] });
+        });
+        it('does not read a foreign tenant or another plan shift', async () => {
+            const { plan, shift } = await setupAutofill();
+            await expect(shiftsService.autofillShift(plan._id, shift._id, { ...options, company: 'foreign' })).rejects.toThrow('SHIFT_PLAN_NOT_FOUND');
+            await expect(shiftsService.autofillShift(plan._id, shift._id, { ...options, project: 'foreign' })).rejects.toThrow('SHIFT_PLAN_NOT_FOUND');
+            await expect(shiftsService.autofillShift(plan._id, new ObjectId(), options)).rejects.toThrow('SHIFT_NOT_FOUND');
+            const sibling = await setupPlan();
+            await expect(shiftsService.autofillShift(sibling._id, shift._id, options)).rejects.toThrow('SHIFT_NOT_FOUND');
+        });
+        it('returns the resolved suggestion as a report without persisting it', async () => {
+            const { plan, shift } = await setupAutofill({ requiredPeople: 2 });
+            const before = await ShiftModel.db.findOne({ _id: shift._id });
+            const report = await shiftsService.autofillShiftReport(plan._id, shift._id, options);
+            const suggested = [secondParticipantId.toHexString(), participantId.toHexString()];
+            expect(report._id.equals(shift._id)).toBe(true);
+            expect((report.assignments || []).map((assignment) => assignment.participant.toHexString())).toEqual(suggested);
+            expect(report.participants.map((participant) => participant.participant.toHexString())).toEqual(suggested);
+            // all scheduling rules run, so a clean suggestion has no violations
+            expect(report.violations).toEqual([]);
+            expect(await ShiftModel.db.findOne({ _id: shift._id })).toEqual(before);
+        });
+    });
+    describe('scope shift autofill', () => {
+        it('reuses preparation and reads the company conflict window only once', async () => {
+            const plan = await setupPlan();
+            await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const shiftReads = jest.spyOn(ShiftModel.db, 'find');
+            const settingsReads = jest.spyOn(settingsService, 'singleSettings');
+            const participantReads = jest.spyOn(ParticipantsModel.db, 'find');
+            const customerReads = jest.spyOn(CustomersModel.db, 'find');
+            const structureReads = jest.spyOn(StructureModel.db, 'find');
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(shiftReads.mock.calls.filter(([query]) => query && 'assignments.customer' in query)).toHaveLength(1);
+            expect(settingsReads).toHaveBeenCalledTimes(1);
+            expect(participantReads).toHaveBeenCalledTimes(2);
+            expect(customerReads).toHaveBeenCalledTimes(2);
+            expect(structureReads).toHaveBeenCalledTimes(2);
+        });
+        it('does not expand the conflict window around distant neighbours', async () => {
+            const plan = await setupPlan();
+            const target = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const storedPlan = (await ShiftPlanModel.db.findOne({ _id: plan._id }));
+            const storedShift = (await ShiftModel.db.findOne({ _id: target._id }));
+            const neighbourPlan = new ObjectId();
+            const distantPlan = new ObjectId();
+            await ShiftPlanModel.db.insertMany([{ ...storedPlan, _id: neighbourPlan }, { ...storedPlan, _id: distantPlan }]);
+            await ShiftModel.db.insertMany([
+                { ...storedShift, _id: new ObjectId(), plan: neighbourPlan, start: '2027-08-01T08:00:00.000Z', end: '2027-08-01T12:00:00.000Z',
+                    assignments: [{ participant: secondParticipantId, customer: secondCustomerId, breaks: [] }] },
+                { ...storedShift, _id: new ObjectId(), plan: distantPlan, start: '2028-05-01T08:00:00.000Z', end: '2028-05-01T12:00:00.000Z',
+                    assignments: [{ participant: secondParticipantId, customer: secondCustomerId, breaks: [] }] },
+            ]);
+            const planReads = jest.spyOn(plansService, 'plansForCompany');
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(reports[0].violations).toEqual([]);
+            expect(planReads).toHaveBeenCalledTimes(1);
+            expect(planReads.mock.calls[0][0].map((id) => id.toHexString())).toEqual([neighbourPlan.toHexString()]);
+        });
+        it('still protects a future shift governed by another project rest override', async () => {
+            const plan = await setupPlan();
+            const target = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 2, start: `${day}T20:00:00+02:00`, end: `${day}T23:00:00+02:00`,
+            }), options);
+            const otherListId = new ObjectId();
+            const otherParticipantId = new ObjectId();
+            const otherOptions = { ...options, project: 'other-project' };
+            await settingsService.changeSettings({ settings: policy() }, otherOptions);
+            await ListsModel.db.insertOne({ ...list, _id: otherListId, project: otherOptions.project });
+            await ParticipantsModel.db.insertOne({ ...participant, _id: otherParticipantId, user: secondCustomerId, project: otherOptions.project, list: otherListId });
+            const otherPlan = await otherProjectPlan(otherListId, otherOptions, { minimumRest: { enabled: true, minutes: 660 } });
+            await shiftsService.createShift(otherPlan._id, shiftInput(otherPlan, planAreas(otherPlan)[0].area, {
+                day: nextDay, assignments: [{ participant: otherParticipantId }],
+            }), otherOptions);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: target._id }, options);
+            expect(reports[0].assignments.map((assignment) => assignment.participant.toHexString())).toEqual([participantId.toHexString()]);
+            expect(reports[0].violations).toEqual([]);
+        });
+        it('fills every under-staffed shift of a plan without double booking a person', async () => {
+            const plan = await setupPlan();
+            const morning = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, {
+                assignments: [], requiredPeople: 1, start: `${day}T08:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+            }), options);
+            const evening = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [], requiredPeople: 1, start: `${day}T12:00:00+02:00`, end: `${day}T20:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'plan', plan: plan._id }, options);
+            const byId = new Map(reports.map((report) => [report._id.toHexString(), report]));
+            expect([...byId.keys()].sort()).toEqual([morning._id.toHexString(), evening._id.toHexString()].sort());
+            const morningAssignee = byId.get(morning._id.toHexString()).assignments.map((assignment) => assignment.participant.toHexString());
+            const eveningAssignee = byId.get(evening._id.toHexString()).assignments.map((assignment) => assignment.participant.toHexString());
+            expect(morningAssignee).toHaveLength(1);
+            expect(eveningAssignee).toHaveLength(1);
+            // The shifts overlap, so the shared allocation cannot reuse the same person.
+            expect(morningAssignee[0]).not.toBe(eveningAssignee[0]);
+        });
+        it('restricts a day scope to that day only', async () => {
+            const plan = await setupPlan();
+            const today = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const tomorrow = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, {
+                assignments: [], requiredPeople: 1, day: nextDay, start: `${nextDay}T08:00:00+02:00`, end: `${nextDay}T16:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'day', plan: plan._id, day: dayId(plan, day) }, options);
+            expect(reports.map((report) => report._id.toHexString())).toEqual([today._id.toHexString()]);
+            expect((await ShiftModel.db.findOne({ _id: tomorrow._id })).assignments).toEqual([]);
+        });
+        it('restricts a work area scope to that area only', async () => {
+            const plan = await setupPlan();
+            const housekeeping = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reception = await shiftsService.createShift(plan._id, shiftInput(plan, receptionAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reports = await shiftsService.autofill({ level: 'workArea', plan: plan._id, workArea: housekeepingAreaId }, options);
+            expect(reports.map((report) => report._id.toHexString())).toEqual([housekeeping._id.toHexString()]);
+            expect((await ShiftModel.db.findOne({ _id: reception._id })).assignments).toEqual([]);
+        });
+        it('fills a single shift for a shift scope without persisting it', async () => {
+            const plan = await setupPlan();
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: shift._id }, options);
+            expect(reports).toHaveLength(1);
+            expect(reports[0]._id.equals(shift._id)).toBe(true);
+            expect(reports[0].assignments).toHaveLength(1);
+            expect(reports[0].violations).toEqual([]);
+            expect((await ShiftModel.db.findOne({ _id: shift._id })).assignments).toEqual([]);
+        });
+        it('treats an overlapping shift in another plan as a conflict neighbour', async () => {
+            const plan = await setupPlan();
+            const shift = await shiftsService.createShift(plan._id, shiftInput(plan, housekeepingAreaId, { assignments: [], requiredPeople: 1 }), options);
+            const sibling = await setupPlan();
+            await shiftsService.createShift(sibling._id, shiftInput(sibling, housekeepingAreaId, {
+                assignments: [{ participant: secondParticipantId }], start: `${day}T08:00:00+02:00`, end: `${day}T16:00:00+02:00`,
+            }), options);
+            const reports = await shiftsService.autofill({ level: 'shift', plan: plan._id, shift: shift._id }, options);
+            expect(reports[0].assignments.map((assignment) => assignment.participant.toHexString())).toEqual([participantId.toHexString()]);
+        });
+    });
+});
+//# sourceMappingURL=shiftPlanning.spec.js.map