dsh-offwork 1.0.1 → 1.1.1

package/pet-view.js

@@ -0,0 +1,323 @@
+// Independent Harness pet presentation. No third-party pet code or assets.
+export const PET_MODEL = Object.freeze({ id: 'xiaoxie-original', renderer: 'svg', license: 'MIT' });
+
+export const PET_MODELS = Object.freeze({
+  'whale-ornate-actions': {
+    id: 'whale-ornate-actions',
+    renderer: 'video',
+    widthScale: 1.3125,
+    heightScale: 2.1,
+    label: 'petWhaleOrnateActions',
+  },
+  'whale-actions': {
+    id: 'whale-actions',
+    renderer: 'video',
+    widthScale: 1.3125,
+    heightScale: 2.1,
+    label: 'petWhaleActions',
+  },
+  'whale-dress': {
+    id: 'whale-dress',
+    renderer: 'image',
+    widthScale: 1.3125,
+    heightScale: 2.1,
+    label: 'petWhaleDress',
+  },
+  'whale-ornate': {
+    id: 'whale-ornate',
+    renderer: 'image',
+    widthScale: 1.3125,
+    heightScale: 2.1,
+    label: 'petWhaleOrnate',
+  },
+  'xiaoxie-original': { ...PET_MODEL, widthScale: 1, heightScale: 1.1, label: 'petDroplet' },
+});
+export function petModel(id) {
+  return Object.hasOwn(PET_MODELS, id) ? PET_MODELS[id] : PET_MODELS['whale-dress'];
+}
+
+export function petLayout(
+  position,
+  viewport,
+  size = 132,
+  contentHeight = 420,
+  modelId = 'xiaoxie-original',
+) {
+  const model = petModel(modelId);
+  const originX = viewport.left ?? 0,
+    originY = viewport.top ?? 0;
+  const edge = 12,
+    gap = 12;
+  const width = Math.max(1, viewport.width),
+    height = Math.max(1, viewport.height);
+  const artworkSize = Math.max(
+    1,
+    Math.min(
+      size,
+      Math.max(1, (width - edge * 2) / model.widthScale),
+      Math.max(1, Math.floor((height - edge * 2 - 30) / model.heightScale)),
+    ),
+  );
+  const petWidth = Math.min(
+    Math.max(1, width - edge * 2),
+    Math.max(148, artworkSize * model.widthScale),
+  );
+  const petHeight = Math.ceil(artworkSize * model.heightScale) + 30;
+  const bound = (n, max) => Math.max(Math.min(edge, max), Math.min(n, max));
+  const x = bound(
+    Number.isFinite(position?.x) ? position.x - originX : width - petWidth - 32,
+    Math.max(0, width - petWidth - edge),
+  );
+  const y = bound(
+    Number.isFinite(position?.y) ? position.y - originY : height - petHeight - 36,
+    Math.max(0, height - petHeight - edge),
+  );
+  const panelWidth = Math.min(296, Math.max(1, width - edge * 2));
+  let side =
+    x >= panelWidth + gap + edge
+      ? 'left'
+      : width - x - petWidth >= panelWidth + gap + edge
+        ? 'right'
+        : 'stack';
+  let maxHeight = Math.max(60, height - edge * 2);
+  let left = side === 'left' ? x - gap - panelWidth : x + petWidth + gap;
+  let top;
+  if (side === 'stack') {
+    left = Math.max(edge, Math.min(x + petWidth - panelWidth, width - panelWidth - edge));
+    const above = y - gap - edge;
+    const below = height - y - petHeight - gap - edge;
+    if (Math.max(above, below) < 48) {
+      side = 'overlay';
+      maxHeight = Math.max(1, height - edge * 2);
+      top = Math.min(edge, height / 2);
+    } else {
+      side = above >= below ? 'above' : 'below';
+      maxHeight = Math.max(48, side === 'above' ? above : below);
+      top = side === 'above' ? y - gap - Math.min(contentHeight, maxHeight) : y + petHeight + gap;
+    }
+  } else {
+    top = Math.max(
+      edge,
+      Math.min(y + petHeight - contentHeight, height - Math.min(contentHeight, maxHeight) - edge),
+    );
+  }
+  return {
+    x: x + originX,
+    y: y + originY,
+    petWidth,
+    artworkSize,
+    petHeight,
+    panel: {
+      left: left + originX,
+      top: Math.max(0, top) + originY,
+      width: panelWidth,
+      maxHeight,
+      side,
+    },
+  };
+}
+
+// Original full-body Xiaoxie: droplet body, small feet and a scarf.
+export function petArtwork(
+  h,
+  presentation,
+  size,
+  reaction = '',
+  modelId = 'xiaoxie-original',
+  sprites = {},
+  interactive = false,
+) {
+  const { pose, animate } = presentation;
+  const model = petModel(modelId);
+  if (['image', 'video'].includes(model.renderer) && sprites[model.id]) {
+    if (model.renderer === 'video' && interactive)
+      return h(
+        'span',
+        {
+          key: model.id,
+          className: 'owc-pet-art owc-pet-video-art',
+          'aria-hidden': true,
+          'data-interactive': true,
+          'data-pose': pose,
+          'data-animate': animate,
+          style: { width: size * model.widthScale, height: size * model.heightScale },
+        },
+        h('img', {
+          src: sprites[model.id],
+          alt: '',
+          draggable: false,
+          className: 'owc-pet-video-poster',
+        }),
+        h('span', { className: 'owc-pet-video-layer' }),
+      );
+    return h('img', {
+      key: interactive ? model.id : model.id + ':' + pose + ':' + reaction,
+      'data-interactive': interactive || undefined,
+      src: sprites[model.id],
+      alt: '',
+      'aria-hidden': true,
+      draggable: false,
+      width: size * model.widthScale,
+      height: size * model.heightScale,
+      className: 'owc-pet-art owc-pet-portrait',
+      'data-pose': pose,
+      'data-animate': animate,
+    });
+  }
+  const asleep = ['quiet', 'rest'].includes(pose);
+  const path = (d, props = {}) => h('path', { d, ...props });
+  return h(
+    'svg',
+    {
+      key: interactive ? model.id : pose + ':' + reaction,
+      'data-interactive': interactive || undefined,
+      viewBox: '0 0 160 176',
+      width: size,
+      height: size * 1.1,
+      className: 'owc-pet-art',
+      'data-pose': pose,
+      'data-animate': animate,
+      'aria-hidden': true,
+      focusable: false,
+    },
+    h('ellipse', { cx: 80, cy: 160, rx: 42, ry: 6, fill: '#183b65', opacity: 0.13 }),
+    h(
+      'g',
+      {
+        className: 'owc-pet-body',
+        stroke: '#315b82',
+        strokeWidth: 2.2,
+        strokeLinecap: 'round',
+        strokeLinejoin: 'round',
+      },
+      h('ellipse', { cx: 58, cy: 148, rx: 12, ry: 8, fill: '#92cce2' }),
+      h('ellipse', { cx: 102, cy: 148, rx: 12, ry: 8, fill: '#92cce2' }),
+      path(
+        pose === 'happy' ? 'M36 86Q14 91 15 65Q28 65 43 76Z' : 'M36 87Q15 87 19 109Q31 113 44 99Z',
+        { fill: '#a4dcea' },
+      ),
+      path(
+        pose === 'happy'
+          ? 'M124 86Q146 91 145 65Q132 65 117 76Z'
+          : 'M124 87Q145 87 141 109Q129 113 116 99Z',
+        { fill: '#a4dcea' },
+      ),
+      path(
+        'M80 12C67 34 38 47 34 81C29 117 46 149 80 149C114 149 131 117 126 81C122 47 93 34 80 12Z',
+        { fill: '#c7eaf3' },
+      ),
+      path('M64 37Q48 53 44 69', { fill: 'none', stroke: '#fff', strokeWidth: 6, opacity: 0.8 }),
+      path('M46 113Q80 126 114 113L109 128Q79 137 51 127Z', { fill: '#fff1bc', stroke: '#b49454' }),
+      path('M102 123L113 145L100 147L92 127Z', { fill: '#ffe39b', stroke: '#b49454' }),
+      h('ellipse', { cx: 80, cy: 111, rx: 8, ry: 5, fill: '#e5f6fa', stroke: 'none' }),
+      asleep
+        ? path('M51 79Q59 85 67 79M93 79Q101 85 109 79', {
+            fill: 'none',
+            stroke: '#24425d',
+            strokeWidth: 3,
+          })
+        : h(
+            'g',
+            { fill: '#24425d', stroke: 'none' },
+            h('ellipse', { cx: 59, cy: 78, rx: 3.5, ry: 5 }),
+            h('ellipse', { cx: 101, cy: 78, rx: 3.5, ry: 5 }),
+          ),
+      path(
+        pose === 'happy'
+          ? 'M69 91Q80 108 91 91Z'
+          : pose === 'offline'
+            ? 'M74 95H86'
+            : 'M72 93Q80 101 88 93',
+        { fill: pose === 'happy' ? '#f19baf' : 'none', stroke: '#24425d', strokeWidth: 2.5 },
+      ),
+      h(
+        'g',
+        { fill: '#f0a2af', stroke: 'none', opacity: 0.65 },
+        h('ellipse', { cx: 46, cy: 91, rx: 8, ry: 4 }),
+        h('ellipse', { cx: 114, cy: 91, rx: 8, ry: 4 }),
+      ),
+      pose === 'drink' &&
+        h(
+          'g',
+          { fill: '#fff', stroke: '#44728f' },
+          path('M113 103H139L135 133H117Z'),
+          path('M140 108H146Q154 121 138 122', { fill: 'none' }),
+          path('M119 115H134', { stroke: '#6dc9e2', strokeWidth: 5 }),
+        ),
+      pose === 'quiet' &&
+        path('M122 32H135L122 44H135', { fill: 'none', stroke: '#67899c', strokeWidth: 3 }),
+    ),
+  );
+}
+
+export const PET_MESSAGES = {
+  zh: {
+    petGreet: '与角色互动',
+    petCharacter: '角色形象',
+    petWhaleActions: '鲸蓝少女 · 长裙动态',
+    petWhaleOrnateActions: '鲸蓝少女 · 短裙动态',
+    petWhaleDress: '鲸蓝少女 · 长裙',
+    petWhaleOrnate: '鲸蓝少女 · 礼裙',
+    petDroplet: '小歇 · 水滴',
+    petClose: '收起宠物面板',
+    petQuick: '日常陪伴',
+    petDetails: '下班与收入',
+    petSize: '宠物大小',
+    petHint: '左键互动 · 右键菜单 · 拖动移动',
+    petMode: '宠物模式',
+    petClock: '下班倒计时',
+  },
+  en: {
+    petGreet: 'Interact with character',
+    petCharacter: 'Character',
+    petWhaleActions: 'Blue whale · Animated long dress',
+    petWhaleOrnateActions: 'Blue whale · Animated short dress',
+    petWhaleDress: 'Blue whale · Long dress',
+    petWhaleOrnate: 'Blue whale · Ornate dress',
+    petDroplet: 'Xiaoxie · Droplet',
+    petClose: 'Close pet panel',
+    petQuick: 'Daily companion',
+    petDetails: 'Clock and earnings',
+    petSize: 'Pet size',
+    petHint: 'Click to interact · right-click for menu · drag to move',
+    petMode: 'Pet mode',
+    petClock: 'Shift countdown',
+  },
+};
+
+export const PET_STYLE = `
+.owc-v2.owc-pet-shell{border-radius:0;touch-action:none;cursor:default;overflow:visible}
+.owc-pet-stage{display:flex;flex-direction:column;align-items:center;position:relative}
+.owc-v2 button.owc-pet-handle{padding:0;background:none!important;border-radius:50%;min-height:0;display:block;cursor:grab;touch-action:none;line-height:0}
+.owc-v2 button.owc-pet-handle:active{cursor:grabbing}
+.owc-pet-art{overflow:visible;pointer-events:none;filter:drop-shadow(0 3px 5px #32557418)}
+.owc-pet-video-art{display:block;position:relative}
+.owc-pet-video-poster,.owc-pet-video-layer,.owc-pet-video-layer video{position:absolute;inset:0;width:100%;height:100%;object-fit:contain;pointer-events:none}
+.owc-pet-video-poster{opacity:1;transition:opacity .12s linear}
+.owc-pet-video-layer video{opacity:0;transition:opacity .12s linear}
+.owc-pet-video-art[data-video-playing=true] .owc-pet-video-poster{opacity:0}
+.owc-pet-video-art[data-video-playing=true] .owc-pet-video-layer video{opacity:1}
+.owc-pet-portrait{display:block;object-fit:contain;transform-origin:50% 90%}
+.owc-pet-portrait[data-animate=true]:not([data-interactive=true]){animation:owc-portrait-thanks .65s ease-in-out 2}
+.owc-pet-art[data-interactive=true]{transform-origin:50% 90%}
+.owc-pet-art[data-interactive=true][data-motion=idle]:not([data-action]){animation:owc-pet-breathe 4.5s ease-in-out infinite}
+@keyframes owc-pet-breathe{0%,100%{transform:translateY(0) scale(1)}50%{transform:translateY(-2px) scale(1.006)}}
+@keyframes owc-portrait-thanks{0%,100%{transform:translateY(0)}45%{transform:translateY(-3px) rotate(-1deg)}75%{transform:rotate(1deg)}}
+.owc-pet-art[data-pose=offline]{opacity:.65}
+.owc-pet-art[data-animate=true]:not([data-interactive=true]) .owc-pet-body{transform-origin:80px 150px;animation:owc-pet-thanks .65s ease-in-out 2}
+@keyframes owc-pet-thanks{0%,100%{transform:translateY(0)}45%{transform:translateY(-4px) rotate(-3deg)}75%{transform:rotate(2deg)}}
+.owc-v2 .owc-pet-clock{display:flex;align-items:center;color:var(--owc-text);line-height:1.5;cursor:default;padding:4px 10px;min-height:26px;gap:5px;white-space:nowrap;border-radius:999px;font-size:11px;background:var(--dsw-alias-bg-overlay);border:1px solid color-mix(in srgb,var(--owc-accent) 25%,transparent);box-shadow:0 3px 12px #142e4812;font-variant-numeric:tabular-nums;max-width:100%;box-sizing:border-box;overflow:hidden}
+.owc-pet-clock-label{min-width:0;overflow:hidden;text-overflow:ellipsis}
+.owc-pet-clock strong{flex:none}
+.owc-pet-panel{position:fixed;border-radius:20px;cursor:default;touch-action:manipulation;max-width:calc(100vw - 24px)}
+.owc-pet-panel>.owc-content{max-height:inherit}
+.owc-pet-panel .owc-glass{opacity:max(var(--owc-alpha),.94)}
+.owc-pet-tabs{display:flex;gap:5px;padding:8px 14px 0}
+.owc-pet-tabs button{flex:1;font-size:11px}
+.owc-pet-tabs button[aria-pressed=true]{color:var(--owc-accent);background:color-mix(in srgb,var(--owc-accent) 10%,transparent)}
+.owc-pet-time{padding:12px 17px 0;display:flex;align-items:center;justify-content:space-between;gap:8px;color:var(--dsw-alias-label-secondary);font-size:11px}
+.owc-pet-time strong{font-size:21px;color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums}
+.owc-pet-speech{padding:12px 16px;font-size:12px;line-height:1.65}
+.owc-pet-speech strong{display:block;font-size:11px;color:var(--dsw-alias-label-secondary);margin-bottom:4px}
+@media(prefers-reduced-motion:reduce){.owc-pet-art,.owc-pet-art *{animation:none!important;transition:none!important}}
+`;

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/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));
+});