dsh-offwork 1.0.0 → 1.1.0

package/tests/clock.test.mjs

@@ -3,23 +3,35 @@ import assert from 'node:assert/strict';
 import { calculate } from '../clock.js';
 
 const base = {
-  monthlySalary: 10000, workdaysPerMonth: 20,
-  start: '09:00', end: '18:00', breakStart: '12:00', breakEnd: '13:00',
-  weekdays: [1, 2, 3, 4, 5], timezone: 'Asia/Shanghai',
+  monthlySalary: 10000,
+  workdaysPerMonth: 20,
+  start: '09:00',
+  end: '18:00',
+  breakStart: '12:00',
+  breakEnd: '13:00',
+  weekdays: [1, 2, 3, 4, 5],
+  timezone: 'Asia/Shanghai',
 };
 const at = (time, patch = {}) => calculate({ ...base, ...patch }, Date.parse(time));
 const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
 const utc = { timezone: 'UTC' };
 
 for (const [time, status, progress] of [
-  ['08:00', 'before', 0], ['09:00', 'working', 0], ['11:00', 'working', 0.25],
-  ['12:00', 'lunch', 0.375], ['12:59', 'lunch', 0.375],
-  ['13:00', 'working', 0.375], ['17:00', 'working', 0.875], ['18:00', 'done', 1], ['23:59', 'done', 1],
-]) test(`same-day boundary ${time}: ${status}`, () => {
-  const result = at(`2026-11-02T${time}:00+08:00`);
-  assert.equal(result.status, status);
-  assert.equal(result.progress, progress);
-});
+  ['08:00', 'before', 0],
+  ['09:00', 'working', 0],
+  ['11:00', 'working', 0.25],
+  ['12:00', 'lunch', 0.375],
+  ['12:59', 'lunch', 0.375],
+  ['13:00', 'working', 0.375],
+  ['17:00', 'working', 0.875],
+  ['18:00', 'done', 1],
+  ['23:59', 'done', 1],
+])
+  test(`same-day boundary ${time}: ${status}`, () => {
+    const result = at(`2026-11-02T${time}:00+08:00`);
+    assert.equal(result.status, status);
+    assert.equal(result.progress, progress);
+  });
 
 test('before has both actual end countdown and start countdown', () => {
   const result = at('2026-11-02T08:00:00+08:00');
@@ -65,7 +77,11 @@ test('night break after midnight is normalized into the shift', () => {
   assert.equal(result.total, 7 * 3600);
 });
 test('break spanning midnight is normalized', () => {
-  const result = at('2026-11-03T00:15:00+08:00', { ...night, breakStart: '23:30', breakEnd: '00:30' });
+  const result = at('2026-11-03T00:15:00+08:00', {
+    ...night,
+    breakStart: '23:30',
+    breakEnd: '00:30',
+  });
   assert.equal(result.status, 'lunch');
   assert.equal(result.elapsed, 1.5 * 3600);
 });
@@ -109,7 +125,10 @@ test('configured Sunday workday overrides weekday assumptions', () => {
 });
 test('daily salary ignores monthly fields and truncates cents', () => {
   const result = at('2026-11-02T18:00:00+08:00', {
-    payMode: 'daily', dailySalary: 123.459, monthlySalary: undefined, workdaysPerMonth: undefined,
+    payMode: 'daily',
+    dailySalary: 123.459,
+    monthlySalary: undefined,
+    workdaysPerMonth: undefined,
   });
   assert.equal(result.payMode, 'daily');
   assert.equal(result.daily, 123.45);
@@ -148,7 +167,13 @@ test('fractional-zone offset is handled independently of system timezone', () =>
   assert.equal(result.progress, 0);
 });
 test('DST spring night countdown measures real elapsed seconds', () => {
-  const patch = { ...night, timezone: 'America/New_York', weekdays: [6], breakStart: '00:00', breakEnd: '00:00' };
+  const patch = {
+    ...night,
+    timezone: 'America/New_York',
+    weekdays: [6],
+    breakStart: '00:00',
+    breakEnd: '00:00',
+  };
   const result = at('2026-03-08T06:00:00Z', patch);
   assert.equal(result.shiftDate, '2026-03-07');
   assert.equal(result.total, 7 * 3600);
@@ -156,7 +181,13 @@ test('DST spring night countdown measures real elapsed seconds', () => {
   assert.equal(result.remaining, 4 * 3600);
 });
 test('DST fall night countdown includes the repeated hour', () => {
-  const patch = { ...night, timezone: 'America/New_York', weekdays: [6], breakStart: '00:00', breakEnd: '00:00' };
+  const patch = {
+    ...night,
+    timezone: 'America/New_York',
+    weekdays: [6],
+    breakStart: '00:00',
+    breakEnd: '00:00',
+  };
   const result = at('2026-11-01T06:30:00Z', patch);
   assert.equal(result.total, 9 * 3600);
   assert.equal(result.elapsed, 4.5 * 3600);
@@ -169,25 +200,37 @@ test('subsecond countdown rounds upwards and salary remains truncated', () => {
 });
 for (const [label, patch, begin] of [
   ['monthly lunch', {}, '2026-11-02T00:00:00+08:00'],
-  ['daily no lunch', { payMode: 'daily', dailySalary: 109.99, breakStart: '00:00', breakEnd: '00:00' }, '2026-11-02T00:00:00+08:00'],
-  ['night cross-midnight lunch', { ...night, breakStart: '23:30', breakEnd: '00:30' }, '2026-11-02T22:00:00+08:00'],
+  [
+    'daily no lunch',
+    { payMode: 'daily', dailySalary: 109.99, breakStart: '00:00', breakEnd: '00:00' },
+    '2026-11-02T00:00:00+08:00',
+  ],
+  [
+    'night cross-midnight lunch',
+    { ...night, breakStart: '23:30', breakEnd: '00:30' },
+    '2026-11-02T22:00:00+08:00',
+  ],
   ['decimal cents', { monthlySalary: 0.29, workdaysPerMonth: 1 }, '2026-11-02T00:00:00+08:00'],
-]) test(`whole-day minute grid: monotone and bounded (${label})`, () => {
-  let previous = 0;
-  const start = Date.parse(begin);
-  // Stop before the next civil day / shift resets its earnings.
-  const last = 1439;
-  for (let minute = 0; minute <= last; minute++) {
-    const result = calculate({ ...base, ...patch }, start + minute * 60000);
-    assert.ok(result.earnedCents >= previous, `${label} minute ${minute} regressed`);
-    assert.ok(result.earnedCents <= result.dailyCents);
-    assert.ok(result.progress >= 0 && result.progress <= 1);
-    assert.equal(Number.isInteger(result.earnedCents), true);
-    previous = result.earnedCents;
-  }
-  assert.equal(previous, calculate({ ...base, ...patch }, start).dailyCents);
-});
+])
+  test(`whole-day minute grid: monotone and bounded (${label})`, () => {
+    let previous = 0;
+    const start = Date.parse(begin);
+    // Stop before the next civil day / shift resets its earnings.
+    const last = 1439;
+    for (let minute = 0; minute <= last; minute++) {
+      const result = calculate({ ...base, ...patch }, start + minute * 60000);
+      assert.ok(result.earnedCents >= previous, `${label} minute ${minute} regressed`);
+      assert.ok(result.earnedCents <= result.dailyCents);
+      assert.ok(result.progress >= 0 && result.progress <= 1);
+      assert.equal(Number.isInteger(result.earnedCents), true);
+      previous = result.earnedCents;
+    }
+    assert.equal(previous, calculate({ ...base, ...patch }, start).dailyCents);
+  });
 test('invalid empty shift or external break fails explicitly', () => {
   assert.throws(() => at('2026-11-02T10:00:00Z', { start: '09:00', end: '09:00' }), RangeError);
-  assert.throws(() => at('2026-11-02T10:00:00Z', { breakStart: '18:00', breakEnd: '19:00' }), RangeError);
+  assert.throws(
+    () => at('2026-11-02T10:00:00Z', { breakStart: '18:00', breakEnd: '19:00' }),
+    RangeError,
+  );
 });

package/tests/companion.test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { companionPresentation, COMPANION_MESSAGES } from '../companion.js';
+import { normalizeView } from '../ui-utils.js';
+const show = (patch = {}) =>
+  companionPresentation({ workStatus: 'working', phase: 'countdown', ...patch });
+const drink = { kind: 'drink', key: 'waterRecorded', token: 12 };
+
+test('only a leased due reminder changes the character to a drinking pose; it adds no second message', () => {
+  const elsewhere = show({ phase: 'due', ownsPrompt: false });
+  assert.equal(elsewhere.pose, 'calm');
+  assert.equal(elsewhere.announce, false);
+  const here = show({ phase: 'due', ownsPrompt: true });
+  assert.equal(here.pose, 'drink');
+  assert.equal(here.message, null);
+  assert.equal(here.announce, false);
+});
+
+test('explicit drink feedback is acknowledged once; quiet and break states never celebrate or animate', () => {
+  const happy = show({ feedback: drink });
+  assert.equal(happy.pose, 'happy');
+  assert.equal(happy.animate, true);
+  assert.equal(happy.announce, true);
+  for (const patch of [
+    { phase: 'quiet' },
+    { phase: 'paused' },
+    { workStatus: 'lunch' },
+    { workStatus: 'rest' },
+    { workStatus: 'done' },
+    { workStatus: 'before' },
+  ]) {
+    const result = show({ ...patch, feedback: drink });
+    assert.equal(result.animate, false);
+    assert.equal(result.message, 'waterRecorded');
+  }
+  assert.equal(show({ phase: 'quiet', feedback: drink }).pose, 'quiet');
+  assert.equal(show({ workStatus: 'lunch', feedback: drink }).pose, 'rest');
+  assert.equal(show({ feedback: { ...drink, kind: 'notice' } }).animate, false);
+});
+
+test('hidden character, hidden page, reduced animation preference and unavailable state suppress reactions', () => {
+  const hidden = show({ visible: false, feedback: drink });
+  assert.equal(hidden.visible, false);
+  assert.equal(hidden.message, null);
+  assert.equal(hidden.announce, false);
+  assert.equal(show({ pageVisible: false, feedback: drink }).animate, false);
+  assert.equal(show({ motion: false, feedback: drink }).animate, false);
+  const failed = show({ failed: true, feedback: drink });
+  assert.equal(failed.message, 'companionUnavailable');
+  assert.equal(failed.announce, false);
+  assert.equal(failed.animate, false);
+  assert.equal(show({ ready: false, feedback: drink }).message, 'companionLoading');
+});
+
+test('quiet, paused and work states have stable localized messages with no automatic announcements', () => {
+  const cases = [
+    { phase: 'quiet' },
+    { phase: 'paused' },
+    { workStatus: 'lunch' },
+    { workStatus: 'rest' },
+    { workStatus: 'done' },
+    { workStatus: 'before' },
+    { phase: 'off' },
+    {},
+  ];
+  for (const input of cases) {
+    const result = show(input);
+    assert.equal(result.announce, false);
+    assert.equal(result.animate, false);
+    for (const lang of ['zh', 'en']) assert.ok(COMPANION_MESSAGES[lang][result.message]);
+    assert.deepEqual(show(input), result);
+  }
+  assert.notEqual(show({ phase: 'quiet' }).message, show({}).message);
+  assert.equal(show({ phase: 'paused', workStatus: 'done' }).message, 'companionDone');
+  assert.equal(show({ phase: 'paused', workStatus: 'rest' }).message, 'companionDayOff');
+});
+
+test('existing view data keeps its position, privacy and opacity while explicit companion opt-out survives reload', () => {
+  const old = { mini: false, masked: true, opacity: 0.6, position: { x: 34, y: 56 } };
+  const migrated = normalizeView(old);
+  for (const key of Object.keys(old)) assert.deepEqual(migrated[key], old[key]);
+  assert.equal(migrated.companion, true);
+  const off = { ...migrated, companion: false, companionMotion: false };
+  assert.deepEqual(normalizeView(JSON.parse(JSON.stringify(off))), off);
+  assert.equal(normalizeView({ ...off, companion: true }).companionMotion, false);
+});

package/tests/host.test.mjs

@@ -22,9 +22,11 @@ async function fixture(t) {
   return { dir, file, operate: createOperations(file) };
 }
 
-function valid(patch) { return validateSettings({ ...DEFAULT_SETTINGS, ...patch }); }
+function valid(patch) {
+  return validateSettings({ ...DEFAULT_SETTINGS, ...patch });
+}
 
-test('defaults remain unsaved; real writes persist privately and can be reopened', async t => {
+test('defaults remain unsaved; real writes persist privately and can be reopened', async (t) => {
   const { dir, file, operate } = await fixture(t);
   const initial = await operate('get');
   assert.deepEqual(initial, { ok: true, settings: DEFAULT_SETTINGS, configured: false });
@@ -40,22 +42,32 @@ test('defaults remain unsaved; real writes persist privately and can be reopened
   assert.deepEqual(await readdir(dir), ['data.json']);
 });
 
-test('legacy configuration gains only new defaults, without rewriting on get', async t => {
+test('legacy configuration gains only new defaults, without rewriting on get', async (t) => {
   const { file, operate } = await fixture(t);
   const { payMode, dailySalary, ...legacy } = DEFAULT_SETTINGS;
   legacy.monthlySalary = 12345;
   const bytes = JSON.stringify(legacy);
   await writeFile(file, bytes);
   const migrated = await operate('get');
-  assert.deepEqual(migrated, { ok: true, configured: true, settings: { ...DEFAULT_SETTINGS, monthlySalary: 12345 } });
+  assert.deepEqual(migrated, {
+    ok: true,
+    configured: true,
+    settings: { ...DEFAULT_SETTINGS, monthlySalary: 12345 },
+  });
   assert.equal(await readFile(file, 'utf8'), bytes);
   assert.equal((await operate('set', { dailySalary: 700 })).settings.monthlySalary, 12345);
   assert.equal(JSON.parse(await readFile(file, 'utf8')).payMode, 'monthly');
 });
 
-test('malformed, unknown and incomplete saved data are never overwritten', async t => {
+test('malformed, unknown and incomplete saved data are never overwritten', async (t) => {
   const { file, operate, dir } = await fixture(t);
-  for (const bytes of ['{broken', 'null', '[]', JSON.stringify({ ...DEFAULT_SETTINGS, surprise: true }), JSON.stringify({ start: '09:00' })]) {
+  for (const bytes of [
+    '{broken',
+    'null',
+    '[]',
+    JSON.stringify({ ...DEFAULT_SETTINGS, surprise: true }),
+    JSON.stringify({ start: '09:00' }),
+  ]) {
     await writeFile(file, bytes);
     assert.equal((await operate('get')).ok, false);
     assert.equal((await operate('set', { monthlySalary: 5 })).ok, false);
@@ -72,7 +84,8 @@ test('day and overnight shifts normalize breaks against shift start', () => {
     { start: '22:00', end: '06:00', breakStart: '05:00', breakEnd: '06:00' },
     { start: '22:00', end: '06:00', breakStart: '12:00', breakEnd: '12:00' },
     { breakStart: '00:00', breakEnd: '00:00' },
-  ]) assert.doesNotThrow(() => valid(patch));
+  ])
+    assert.doesNotThrow(() => valid(patch));
   for (const patch of [
     { start: '09:00', end: '09:00' },
     { start: '22:00', end: '06:00' },
@@ -80,30 +93,49 @@ test('day and overnight shifts normalize breaks against shift start', () => {
     { start: '22:00', end: '06:00', breakStart: '22:00', breakEnd: '06:00' },
     { breakStart: '18:00', breakEnd: '19:00' },
     { breakStart: '12:00', breakEnd: '11:00' },
-    { payMode: 'hourly' }, { dailySalary: -1 }, { dailySalary: Infinity },
-    { monthlySalary: NaN }, { workdaysPerMonth: 0 }, { start: '9:00' },
-    { weekdays: [1, 1] }, { timezone: 'not/a-zone' }, { surprise: true },
-  ]) assert.throws(() => valid(patch), JSON.stringify(patch));
+    { payMode: 'hourly' },
+    { dailySalary: -1 },
+    { dailySalary: Infinity },
+    { monthlySalary: NaN },
+    { workdaysPerMonth: 0 },
+    { start: '9:00' },
+    { weekdays: [1, 1] },
+    { timezone: 'not/a-zone' },
+    { surprise: true },
+  ])
+    assert.throws(() => valid(patch), JSON.stringify(patch));
 });
 
-test('invalid patches and actions do not create files; queue recovers', async t => {
+test('invalid patches and actions do not create files; queue recovers', async (t) => {
   const { dir, operate } = await fixture(t);
-  for (const [action, patch] of [['wat'], ['get', {}], ['set'], ['set', []], ['set', { unknown: 1 }], ['set', { payMode: 'weekly' }]]) {
+  for (const [action, patch] of [
+    ['wat'],
+    ['get', {}],
+    ['set'],
+    ['set', []],
+    ['set', { unknown: 1 }],
+    ['set', { payMode: 'weekly' }],
+  ]) {
     assert.equal((await operate(action, patch)).ok, false);
   }
   assert.deepEqual(await readdir(dir), []);
   assert.equal((await operate('set', {})).configured, true);
 });
 
-test('concurrent partial sets serialize and preserve preceding updates', async t => {
+test('concurrent partial sets serialize and preserve preceding updates', async (t) => {
   const { file, operate, dir } = await fixture(t);
-  const patches = [{ monthlySalary: 22222 }, { dailySalary: 999 }, { payMode: 'daily' }, { timezone: 'UTC' }];
-  const pending = patches.map(patch => operate('set', patch));
+  const patches = [
+    { monthlySalary: 22222 },
+    { dailySalary: 999 },
+    { payMode: 'daily' },
+    { timezone: 'UTC' },
+  ];
+  const pending = patches.map((patch) => operate('set', patch));
   pending.push(operate('set', { unknown: true }));
   for (let i = 0; i < 30; i++) pending.push(operate('set', { dailySalary: 1000 + i }));
   const results = await Promise.all(pending);
   assert.equal(results[4].ok, false);
-  assert.ok(results.filter((_, i) => i !== 4).every(result => result.ok));
+  assert.ok(results.filter((_, i) => i !== 4).every((result) => result.ok));
   const expected = { ...DEFAULT_SETTINGS, ...Object.assign({}, ...patches), dailySalary: 1029 };
   assert.deepEqual(JSON.parse(await readFile(file, 'utf8')), expected);
   assert.deepEqual((await operate('get')).settings, expected);
@@ -120,11 +152,21 @@ async function adapters(t) {
   let command;
   let tool;
   module.apply({
-    effect: effect => effect(),
-    commands: { register(definition) { command = definition; return () => {}; } },
-    tools: { register(definition) { tool = definition; return () => {}; } },
+    effect: (effect) => effect(),
+    commands: {
+      register(definition) {
+        command = definition;
+        return () => {};
+      },
+    },
+    tools: {
+      register(definition) {
+        tool = definition;
+        return () => {};
+      },
+    },
   });
-  const runCommand = async rawInput => {
+  const runCommand = async (rawInput) => {
     const response = await command.handler({ rawInput });
     const result = JSON.parse(response.text);
     assert.equal(response.kind, result.ok ? 'success' : 'error');
@@ -133,7 +175,7 @@ async function adapters(t) {
   return { ...fixtureData, tool, command, runCommand };
 }
 
-test('command and tool share results, validation, storage and a write queue', async t => {
+test('command and tool share results, validation, storage and a write queue', async (t) => {
   const { tool, command, runCommand, file } = await adapters(t);
   assert.equal(command.recordInput, false);
   assert.deepEqual(await runCommand('get'), await tool.execute({ action: 'get' }));
@@ -141,7 +183,10 @@ test('command and tool share results, validation, storage and a write queue', as
   assert.deepEqual(await tool.execute({ action: 'get' }), written);
   const second = await tool.execute({ action: 'set', settings: { monthlySalary: 25000 } });
   assert.deepEqual(await runCommand('get'), second);
-  assert.deepEqual(await runCommand('set {"unknown":1}'), await tool.execute({ action: 'set', settings: { unknown: 1 } }));
+  assert.deepEqual(
+    await runCommand('set {"unknown":1}'),
+    await tool.execute({ action: 'set', settings: { unknown: 1 } }),
+  );
   await Promise.all([
     runCommand('set {"dailySalary":750}'),
     tool.execute({ action: 'set', settings: { timezone: 'UTC' } }),
@@ -149,11 +194,13 @@ test('command and tool share results, validation, storage and a write queue', as
   const stored = JSON.parse(await readFile(file, 'utf8'));
   assert.equal(stored.dailySalary, 750);
   assert.equal(stored.timezone, 'UTC');
-  for (const raw of ['get {}', 'set', 'set {bad', 'wat']) assert.equal((await runCommand(raw)).ok, false);
-  for (const args of [null, [], { action: 'get', unknown: true }]) assert.equal((await tool.execute(args)).ok, false);
+  for (const raw of ['get {}', 'set', 'set {bad', 'wat'])
+    assert.equal((await runCommand(raw)).ok, false);
+  for (const args of [null, [], { action: 'get', unknown: true }])
+    assert.equal((await tool.execute(args)).ok, false);
 });
 
-test('tool schemas expose new fields, configured flag, and typed literal branches', async t => {
+test('tool schemas expose new fields, configured flag, and typed literal branches', async (t) => {
   const { tool } = await adapters(t);
   const input = tool.parameters.properties.settings;
   assert.equal(input.additionalProperties, false);
@@ -168,5 +215,7 @@ test('tool schemas expose new fields, configured flag, and typed literal branche
   assert.equal(success.additionalProperties, false);
   assert.equal(failure.additionalProperties, false);
   const result = await tool.execute({ action: 'get' });
-  assert.deepEqual(tool.output.render({}, result), [{ type: 'text', text: JSON.stringify(result) }]);
+  assert.deepEqual(tool.output.render({}, result), [
+    { type: 'text', text: JSON.stringify(result) },
+  ]);
 });

package/tests/hydration-extras.test.mjs

@@ -0,0 +1,226 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { calculate } from '../clock.js';
+import {
+  defaultHydration,
+  validateHydration,
+  hydrationContext,
+  hydrationView,
+  transitionHydration,
+  HYDRATION_ACTION_LIMIT,
+} from '../hydration.js';
+
+const settings = {
+  payMode: 'monthly',
+  monthlySalary: 12000,
+  workdaysPerMonth: 20,
+  start: '09:00',
+  end: '18:00',
+  breakStart: '12:00',
+  breakEnd: '13:00',
+  weekdays: [1, 2, 3, 4, 5],
+  timezone: 'Asia/Shanghai',
+};
+const time = (text) => Date.parse(text.includes('T') ? text : `2026-11-04T${text}:00+08:00`);
+const context = (text, patch = {}) => {
+  const config = { ...settings, ...patch };
+  return hydrationContext(config, calculate(config, time(text)));
+};
+const act = (s, at, a, patch = {}, owner = 'a') =>
+  transitionHydration(s, context(at, patch), a, time(at), owner);
+const view = (s, at, patch = {}) => hydrationView(s, context(at, patch), time(at));
+const enabled = (at = '09:00', interval = 60, patch = {}) =>
+  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval }, patch);
+const manual = (at, id, patch = {}, extra = {}) => ({
+  type: 'manual-drink',
+  actionId: id,
+  shiftId: context(at, patch).id,
+  ...extra,
+});
+
+test('manual check-in restarts an enabled timer and retries are idempotent', () => {
+  const initial = enabled();
+  const action = manual('09:40', 'glass-1');
+  const next = act(initial, '09:40', action);
+  assert.equal(next.shift.count, 1);
+  assert.equal(view(next, '09:40').remaining, 3600000);
+  assert.deepEqual(act(next, '09:45', action), next);
+  assert.equal(initial.shift.count, 0);
+});
+
+test('manual check-ins work with reminders off, preserve pause, and ignore off-hours', () => {
+  let state = act(defaultHydration(), '10:00', manual('10:00', 'off'));
+  assert.equal(state.enabled, false);
+  assert.equal(state.shift.count, 1);
+  state = act(state, '10:00', { type: 'preferences', enabled: true });
+  state = act(state, '10:10', { type: 'pause' });
+  const due = state.shift.due;
+  state = act(state, '10:20', manual('10:20', 'paused'));
+  assert.equal(state.shift.count, 2);
+  assert.equal(state.shift.paused, true);
+  assert.equal(state.shift.due, due);
+  for (const at of ['08:00', '18:00', '2026-11-07T10:00:00+08:00']) {
+    const result = act(defaultHydration(), at, manual(at, at));
+    assert.equal(result.shift, null);
+  }
+});
+
+test('lunch check-in starts a full working interval after lunch', () => {
+  const state = act(enabled('11:00', 5), '12:30', manual('12:30', 'lunch'));
+  assert.equal(state.shift.count, 1);
+  assert.equal(view(state, '12:59').phase, 'break');
+  assert.equal(view(state, '13:00').remaining, 300000);
+  assert.equal(view(state, '13:05').phase, 'due');
+});
+
+test('manual and prompted confirmation of the same due event count once in either order', () => {
+  const initial = act(enabled(), '10:00', { type: 'claim' });
+  const eventId = view(initial, '10:00').eventId;
+  const actions = [manual('10:00', 'due', {}, { eventId }), { type: 'drink', eventId }];
+  for (const order of [actions, [...actions].reverse()]) {
+    let state = initial;
+    for (const action of order) state = act(state, '10:00', action);
+    assert.equal(state.shift.count, 1);
+    assert.equal(state.shift.claim, null);
+  }
+});
+
+test('manual request IDs are bounded, distinct records count, and old-shift retries cannot count tomorrow', () => {
+  let state = enabled();
+  for (let i = 0; i < HYDRATION_ACTION_LIMIT + 3; i++)
+    state = act(state, '09:10', manual('09:10', String(i)));
+  assert.equal(state.shift.count, HYDRATION_ACTION_LIMIT + 3);
+  assert.equal(state.shift.recentActions.length, HYDRATION_ACTION_LIMIT);
+  assert.equal(validateHydration(state).shift.count, state.shift.count);
+  const tomorrow = act(state, '2026-11-05T09:10:00+08:00', manual('09:10', 'old'));
+  assert.equal(tomorrow.shift.count, 0);
+});
+
+test('quiet time suppresses a due prompt, keeps its work deadline, and resumes once at expiry', () => {
+  let state = act(enabled('09:00', 5), '09:05', { type: 'claim' });
+  const oldEvent = view(state, '09:05').eventId;
+  const due = state.shift.due;
+  state = act(state, '09:05', { type: 'quiet', minutes: 30 });
+  assert.equal(state.shift.due, due);
+  assert.equal(state.shift.claim, null);
+  assert.equal(view(state, '09:34').phase, 'quiet');
+  assert.equal(view(state, '09:34').quietRemaining, 60000);
+  assert.equal(act(state, '09:10', { type: 'claim' }).shift.claim, null);
+  assert.equal(act(state, '09:10', { type: 'drink', eventId: oldEvent }).shift.count, 0);
+  assert.equal(view(state, '09:35').phase, 'due');
+  const resumed = act(state, '09:35', { type: 'claim' });
+  assert.equal(resumed.shift.quietUntil, 0);
+  assert.equal(resumed.shift.claim.owner, 'a');
+  assert.equal(view(resumed, '10:30').eventId, view(resumed, '09:35').eventId);
+});
+
+test('quiet time uses natural minutes across lunch and never prompts during lunch', () => {
+  let state = act(enabled('11:00', 5), '11:50', { type: 'quiet', minutes: 30 });
+  assert.equal(view(state, '12:10').quietRemaining, 600000);
+  assert.equal(view(state, '12:20').phase, 'break');
+  assert.equal(view(state, '13:00').phase, 'due');
+  state = act(state, '12:30', manual('12:30', 'lunch-quiet'));
+  assert.equal(view(state, '13:00').remaining, 300000);
+});
+
+test('manual and quiet actions commute and a check-in does not end quiet time', () => {
+  const actions = [manual('09:10', 'concurrent'), { type: 'quiet', minutes: 30 }];
+  for (const order of [actions, [...actions].reverse()]) {
+    let state = enabled('09:00', 5);
+    for (const a of order) state = act(state, '09:10', a);
+    assert.equal(state.shift.count, 1);
+    assert.equal(state.shift.quietUntil, time('09:40'));
+    assert.equal(state.shift.due, context('09:15').elapsed);
+    assert.equal(view(state, '09:14').phase, 'quiet');
+  }
+});
+
+test('quiet duration replaces instead of adding, and can be ended early', () => {
+  let state = act(enabled(), '09:05', { type: 'quiet', minutes: 30 });
+  state = act(state, '09:10', { type: 'quiet', minutes: 60 });
+  assert.equal(state.shift.quietUntil, time('10:10'));
+  state = act(state, '09:20', { type: 'end-quiet' });
+  assert.equal(view(state, '09:20').phase, 'countdown');
+  assert.equal(state.shift.due, 3600000);
+  for (const minutes of [0, 10, 31, 90])
+    assert.throws(() => act(enabled(), '09:10', { type: 'quiet', minutes }));
+});
+
+test('pause and disable clear quiet time, expiry never cancels a full-shift pause', () => {
+  const quiet = act(enabled(), '09:05', { type: 'quiet', minutes: 60 });
+  const paused = act(quiet, '09:10', { type: 'pause' });
+  assert.equal(paused.shift.quietUntil, 0);
+  assert.equal(view(paused, '11:00').phase, 'paused');
+  assert.equal(act(paused, '09:15', { type: 'quiet', minutes: 30 }).shift.quietUntil, 0);
+  const off = act(quiet, '09:10', { type: 'preferences', enabled: false });
+  assert.equal(off.shift.quietUntil, 0);
+  const resumed = act(paused, '09:20', { type: 'resume' });
+  assert.equal(view(resumed, '09:20').remaining, 3600000);
+});
+
+test('quiet mode ends at shift end and does not leak into another shift, including overnight', () => {
+  let state = act(enabled('17:00', 5), '17:50', { type: 'quiet', minutes: 60 });
+  assert.equal(state.shift.quietUntil, time('18:00'));
+  assert.equal(view(state, '18:00').phase, 'waiting');
+  state = act(state, '2026-11-05T09:00:00+08:00', { type: 'tick' });
+  assert.equal(state.shift.quietUntil, 0);
+  const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
+  let overnight = enabled('2026-11-04T22:00:00+08:00', 5, night);
+  overnight = act(overnight, '2026-11-04T23:50:00+08:00', { type: 'quiet', minutes: 30 }, night);
+  assert.equal(view(overnight, '2026-11-05T00:10:00+08:00', night).quietRemaining, 600000);
+  assert.equal(view(overnight, '2026-11-05T00:20:00+08:00', night).phase, 'due');
+});
+
+test('same-shift schedule edits preserve quiet intent, clamp to new end and reject stale manual changes', () => {
+  const state = act(enabled('17:00', 5), '17:05', { type: 'quiet', minutes: 30 });
+  const patch = { end: '17:20' };
+  const updated = act(state, '17:10', { type: 'tick', baseSchedule: state.shift.schedule }, patch);
+  assert.equal(updated.shift.quietUntil, time('17:20'));
+  assert.deepEqual(act(updated, '17:11', manual('17:11', 'stale')), updated);
+  assert.deepEqual(act(updated, '17:11', { type: 'quiet', minutes: 60 }), updated);
+});
+
+test('schema 1 migrates with preferences, count, pause and due intact while revoking the lease', () => {
+  const legacy = act(enabled('09:00', 5), '09:05', { type: 'claim' });
+  legacy.schema = 1;
+  legacy.shift.count = 7;
+  legacy.shift.paused = true;
+  delete legacy.shift.quietUntil;
+  delete legacy.shift.recentActions;
+  const upgraded = validateHydration(legacy);
+  assert.equal(upgraded.schema, 2);
+  assert.equal(upgraded.interval, 5);
+  assert.equal(upgraded.shift.count, 7);
+  assert.equal(upgraded.shift.paused, true);
+  assert.equal(upgraded.shift.due, legacy.shift.due);
+  assert.equal(upgraded.shift.claim, null);
+  assert.equal(upgraded.shift.sequence, legacy.shift.sequence + 1);
+  assert.equal(upgraded.shift.quietUntil, 0);
+  assert.deepEqual(upgraded.shift.recentActions, []);
+  assert.deepEqual(validateHydration(upgraded), upgraded);
+});
+
+test('stale pause and resume actions do not postpone a timer or pause disabled reminders', () => {
+  let state = act(enabled(), '09:10', { type: 'pause' });
+  state = act(state, '09:20', { type: 'resume' });
+  assert.deepEqual(act(state, '09:30', { type: 'resume' }), state);
+  state = act(state, '09:30', { type: 'preferences', enabled: false });
+  assert.deepEqual(act(state, '09:40', { type: 'pause' }), state);
+});
+
+test('malformed new fields and malformed legacy data are rejected', () => {
+  for (const patch of [
+    { quietUntil: -1 },
+    { quietUntil: NaN },
+    { recentActions: null },
+    { recentActions: ['same', 'same'] },
+    { recentActions: Array.from({ length: 65 }, (_, i) => String(i)) },
+  ]) {
+    const state = enabled();
+    Object.assign(state.shift, patch);
+    assert.throws(() => validateHydration(state));
+  }
+  const legacy = enabled();
+  legacy.schema = 1;
+  assert.throws(() => validateHydration(legacy));
+});