dsh-offwork 1.0.1 → 1.1.0

package/companion.js

@@ -0,0 +1,185 @@
+// Presentation only: no clocks, storage, salary data or reminder side effects.
+export function companionPresentation({
+  workStatus,
+  phase,
+  ownsPrompt = false,
+  ready = true,
+  failed = false,
+  feedback = null,
+  visible = true,
+  motion = true,
+  pageVisible = true,
+}) {
+  if (!visible)
+    return { visible: false, pose: 'calm', message: null, announce: false, animate: false };
+  let pose = 'calm';
+  let message = 'companionWorking';
+  const quiet =
+    ['quiet', 'paused'].includes(phase) && !['before', 'done', 'rest'].includes(workStatus);
+  const resting = ['lunch', 'rest', 'done', 'before'].includes(workStatus);
+  if (!ready) {
+    pose = 'rest';
+    message = 'companionLoading';
+  } else if (failed) {
+    pose = 'offline';
+    message = 'companionUnavailable';
+  } else if (quiet) {
+    pose = 'quiet';
+    message = phase === 'quiet' ? 'companionQuiet' : 'companionPaused';
+  } else if (workStatus === 'lunch') {
+    pose = 'rest';
+    message = 'companionBreak';
+  } else if (workStatus === 'rest') {
+    pose = 'rest';
+    message = 'companionDayOff';
+  } else if (workStatus === 'done') {
+    pose = 'happy';
+    message = 'companionDone';
+  } else if (workStatus === 'before') {
+    pose = 'rest';
+    message = 'companionBefore';
+  } else if (phase === 'due' && ownsPrompt) {
+    // The existing leased reminder is the only source of the due message.
+    pose = 'drink';
+    message = null;
+  }
+  let announce = false;
+  let animate = false;
+  if (ready && !failed && !(phase === 'due' && ownsPrompt) && feedback) {
+    message = feedback.key;
+    announce = true;
+    if (feedback.kind === 'drink' && !quiet && !resting) {
+      pose = 'happy';
+      animate = motion && pageVisible;
+    }
+  }
+  return { visible: true, pose, message, announce, animate };
+}
+
+// Original vector character. Its art is decorative; controls and status text
+// provide the accessible names. Stable keys prevent the 1-second clock tick
+// from replaying the reaction animation.
+export function companionArtwork(h, presentation, size = 40, reaction = '') {
+  const { pose, animate } = presentation;
+  const asleep = ['rest', 'quiet'].includes(pose);
+  const path = (d, props = {}) => h('path', { d, ...props });
+  return h(
+    'svg',
+    {
+      key: pose + ':' + reaction,
+      className: 'owc-companion-art',
+      viewBox: '0 0 64 64',
+      width: size,
+      height: size,
+      'aria-hidden': 'true',
+      focusable: 'false',
+      'data-pose': pose,
+      'data-animate': animate,
+    },
+    h('ellipse', { cx: 32, cy: 58, rx: 19, ry: 3, className: 'owc-companion-shadow' }),
+    h(
+      'g',
+      { className: 'owc-companion-body' },
+      path('M32 7C28 18 12 28 12 42C12 54 21 58 32 58S52 54 52 42C52 28 36 18 32 7Z', {
+        className: 'owc-companion-skin',
+      }),
+      path('M25 21C21 25 18 29 17 34', { className: 'owc-companion-shine' }),
+      h(
+        'g',
+        { className: 'owc-companion-face' },
+        asleep
+          ? path('M21 38Q24 41 27 38M37 38Q40 41 43 38')
+          : h(
+              'g',
+              null,
+              h('circle', { cx: 24, cy: 38, r: 1.7, fill: 'currentColor', stroke: 'none' }),
+              h('circle', { cx: 40, cy: 38, r: 1.7, fill: 'currentColor', stroke: 'none' }),
+            ),
+        path(
+          pose === 'happy'
+            ? 'M27 44Q32 51 37 44Z'
+            : pose === 'offline'
+              ? 'M29 46H35'
+              : 'M28 45Q32 49 36 45',
+        ),
+      ),
+      h(
+        'g',
+        { className: 'owc-companion-cheeks' },
+        h('ellipse', { cx: 20, cy: 44, rx: 3, ry: 1.6 }),
+        h('ellipse', { cx: 44, cy: 44, rx: 3, ry: 1.6 }),
+      ),
+      pose === 'happy' && path('M12 44L7 38M52 44L57 38', { className: 'owc-companion-limbs' }),
+      pose === 'drink' &&
+        h(
+          'g',
+          { className: 'owc-companion-cup' },
+          path('M43 41H55L53 54H45Z'),
+          path('M55 43H58Q62 47 55 49', { fill: 'none' }),
+        ),
+      pose === 'quiet' && path('M45 16H51L45 22H51', { className: 'owc-companion-limbs' }),
+    ),
+  );
+}
+
+export const COMPANION_MESSAGES = {
+  zh: {
+    companionName: '小歇',
+    companionLabel: '下班搭子',
+    companionOpen: '打开小歇的快捷操作',
+    companionShow: '显示陪伴角色',
+    companionMotion: '角色动作反馈',
+    companionPreferences: '立即生效，保存在本浏览器。隐藏角色后仍可使用计时和喝水操作。',
+    companionWorking: '你忙你的，我陪你记着时间。',
+    companionQuiet: '好，先安静陪着你。',
+    companionPaused: '本班先不提醒，需要时再叫我。',
+    companionBreak: '休息一下，回来再继续。',
+    companionBefore: '还没开工，先慢慢准备。',
+    companionDone: '这一班结束啦，辛苦了。',
+    companionDayOff: '今天歇一歇，按自己的节奏来。',
+    companionLoading: '稍等，我看看现在的状态。',
+    companionUnavailable: '暂时读不到提醒状态，可以重试读取。',
+  },
+  en: {
+    companionName: 'Xiaoxie',
+    companionLabel: 'Your workday companion',
+    companionOpen: 'Open companion quick actions',
+    companionShow: 'Show companion',
+    companionMotion: 'Character reactions',
+    companionPreferences:
+      'Applies immediately in this browser. Timers and water actions work with the character hidden.',
+    companionWorking: 'Carry on. I’ll keep an eye on the time.',
+    companionQuiet: 'I’ll keep you company quietly.',
+    companionPaused: 'Reminders are paused. Resume whenever you like.',
+    companionBreak: 'Take a break. We can carry on afterward.',
+    companionBefore: 'No rush. Your shift hasn’t started yet.',
+    companionDone: 'That’s your shift done. Take a breather.',
+    companionDayOff: 'A day off. Enjoy your own pace.',
+    companionLoading: 'One moment while I check the status.',
+    companionUnavailable: 'I can’t read reminder status. You can retry loading.',
+  },
+};
+
+export const COMPANION_STYLE = `
+.owc-sr-only{position:absolute!important;width:1px;height:1px;padding:0;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
+.owc-mini-feedback{margin:0;padding:0 14px 9px;max-width:260px;font-size:11px;line-height:1.6;overflow-wrap:anywhere}
+.owc-companion{display:flex;align-items:center;gap:10px;padding:12px 17px 8px;cursor:default}
+.owc-companion-copy{min-width:0;flex:1}
+.owc-companion-name{display:flex;align-items:center;gap:6px;font-size:11px;color:var(--dsw-alias-label-secondary);font-weight:600}
+.owc-companion-name span{font-size:10px;font-weight:400}
+.owc-companion p{margin:5px 0 0;font-size:12px;line-height:1.65;overflow-wrap:anywhere}
+.owc-water .owc-companion{padding:4px 0 8px;border-bottom:1px solid color-mix(in srgb,var(--owc-accent) 10%,transparent);margin-bottom:8px}
+.owc-v2 button.owc-companion-trigger{padding:0;flex:none;min-width:36px;min-height:36px;border-radius:12px}
+.owc-companion-art{flex:none;overflow:visible;color:var(--owc-accent);pointer-events:none}
+.owc-companion-shadow{fill:currentColor;opacity:.12}
+.owc-companion-skin{fill:color-mix(in srgb,var(--owc-accent) 22%,var(--dsw-alias-bg-overlay));stroke:currentColor;stroke-width:1.6;stroke-linejoin:round}
+.owc-companion-shine{fill:none;stroke:white;stroke-width:2.5;stroke-linecap:round;opacity:.75}
+.owc-companion-face{color:var(--dsw-alias-label-primary);fill:none;stroke:currentColor;stroke-width:1.6;stroke-linecap:round;stroke-linejoin:round}
+.owc-companion-cheeks{fill:#ef8d96;opacity:.5}
+.owc-companion-limbs{fill:none;stroke:currentColor;stroke-width:2;stroke-linecap:round;stroke-linejoin:round}
+.owc-companion-cup{fill:var(--dsw-alias-bg-overlay);stroke:currentColor;stroke-width:1.6;stroke-linejoin:round}
+.owc-companion-art[data-pose=offline]{opacity:.65}
+.owc-companion-art[data-animate=true] .owc-companion-body{transform-origin:32px 52px;animation:owc-companion-thanks .65s ease-in-out 2}
+@keyframes owc-companion-thanks{0%,100%{transform:translateY(0) rotate(0)}40%{transform:translateY(-2px) rotate(-3deg)}70%{transform:translateY(0) rotate(2deg)}}
+@media(prefers-reduced-motion:reduce){.owc-companion-art *{animation:none!important;transition:none!important}}
+`;

package/hydration-store.js

@@ -0,0 +1,101 @@
+import { defaultHydration, validateHydration } from './hydration.js';
+
+// A single IndexedDB read/write transaction is the cross-tab mutex. Neither
+// notification delivery nor localStorage read-back is used as an atomic lock.
+export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydration.v1') {
+  let database = null;
+  let opening = null;
+  let closed = false;
+  const open = () => {
+    if (closed) return Promise.reject(new Error('Hydration store closed'));
+    if (database) return Promise.resolve(database);
+    if (opening) return opening;
+    opening = new Promise((resolve, reject) => {
+      let abandoned = false;
+      const fail = (error) => {
+        abandoned = true;
+        reject(error);
+      };
+      if (!indexedDB) {
+        reject(new Error('Hydration storage unavailable'));
+        return;
+      }
+      const request = indexedDB.open(name, 1);
+      request.onupgradeneeded = () => request.result.createObjectStore('state');
+      request.onerror = () => fail(request.error ?? new Error('Hydration storage unavailable'));
+      request.onblocked = () => fail(new Error('Hydration storage blocked'));
+      request.onsuccess = () => {
+        if (closed || abandoned) {
+          request.result.close();
+          reject(new Error('Hydration store closed'));
+          return;
+        }
+        database = request.result;
+        database.onversionchange = () => {
+          database.close();
+          database = null;
+          opening = null;
+        };
+        database.onclose = () => {
+          database = null;
+          opening = null;
+        };
+        resolve(database);
+      };
+    }).catch((error) => {
+      opening = null;
+      throw error;
+    });
+    return opening;
+  };
+  return {
+    async update(reducer, { reset = false } = {}) {
+      const db = await open();
+      if (closed) throw new Error('Hydration store closed');
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction('state', 'readwrite');
+        const store = transaction.objectStore('state');
+        const request = store.get('current');
+        let output;
+        let failure;
+        request.onsuccess = () => {
+          try {
+            const current =
+              reset || request.result === undefined
+                ? defaultHydration()
+                : validateHydration(request.result);
+            const next = validateHydration(reducer(structuredClone(current)));
+            const changed = JSON.stringify(next) !== JSON.stringify(current);
+            const migrated =
+              request.result !== undefined && request.result.schema !== current.schema;
+            if (reset || changed || migrated) {
+              const previousRevision =
+                Number.isSafeInteger(request.result?.revision) && request.result.revision >= 0
+                  ? request.result.revision
+                  : current.revision;
+              next.revision = previousRevision + 1;
+              if (!Number.isSafeInteger(next.revision))
+                throw new Error('Hydration revision exhausted');
+              store.put(next, 'current');
+            }
+            output = next;
+          } catch (error) {
+            failure = error;
+            transaction.abort();
+          }
+        };
+        transaction.oncomplete = () => resolve(output);
+        transaction.onabort = () =>
+          reject(failure ?? transaction.error ?? new Error('Hydration transaction aborted'));
+        transaction.onerror = () => {
+          /* onabort reports the failure once. */
+        };
+      });
+    },
+    close() {
+      closed = true;
+      database?.close();
+      database = null;
+    },
+  };
+}

package/hydration.js

@@ -0,0 +1,303 @@
+// Pure hydration rules. Time is measured in paid-work milliseconds from calculate().
+export const HYDRATION_SCHEMA = 2;
+export const HYDRATION_ACTION_LIMIT = 64;
+export const HYDRATION_LEASE_MS = 8000;
+
+export function defaultHydration() {
+  return { schema: HYDRATION_SCHEMA, revision: 0, enabled: false, interval: 60, shift: null };
+}
+
+export function validateHydration(value) {
+  const integer = (number, max = Number.MAX_SAFE_INTEGER) =>
+    Number.isSafeInteger(number) && number >= 0 && number <= max;
+  const text = (string) => typeof string === 'string' && string.length > 0 && string.length <= 1024;
+  const keys = (object, allowed) =>
+    object &&
+    typeof object === 'object' &&
+    !Array.isArray(object) &&
+    Object.keys(object).every((key) => allowed.includes(key));
+  if (
+    !keys(value, ['schema', 'revision', 'enabled', 'interval', 'shift']) ||
+    ![1, HYDRATION_SCHEMA].includes(value.schema) ||
+    !integer(value.revision) ||
+    typeof value.enabled !== 'boolean' ||
+    !integer(value.interval, 240) ||
+    value.interval < 5
+  ) {
+    throw new Error('Invalid hydration data');
+  }
+  const shift = value.shift;
+  if (shift !== null) {
+    if (
+      !keys(shift, [
+        'id',
+        'schedule',
+        'config',
+        'count',
+        'paused',
+        'due',
+        'sequence',
+        'claim',
+        ...(value.schema === 2 ? ['quietUntil', 'recentActions'] : []),
+      ]) ||
+      !text(shift.id) ||
+      !text(shift.schedule) ||
+      !text(shift.config) ||
+      !integer(shift.count, 1000000) ||
+      typeof shift.paused !== 'boolean' ||
+      !integer(shift.sequence) ||
+      !integer(shift.due, 172800000)
+    ) {
+      throw new Error('Invalid hydration shift');
+    }
+    if (
+      value.schema === 2 &&
+      (!integer(shift.quietUntil) ||
+        !Array.isArray(shift.recentActions) ||
+        shift.recentActions.length > HYDRATION_ACTION_LIMIT ||
+        !shift.recentActions.every((id) => text(id) && id.length <= 128) ||
+        new Set(shift.recentActions).size !== shift.recentActions.length)
+    )
+      throw new Error('Invalid hydration actions');
+    if (
+      shift.claim !== null &&
+      (!keys(shift.claim, ['owner', 'until', 'sequence']) ||
+        !text(shift.claim.owner) ||
+        !integer(shift.claim.until) ||
+        !integer(shift.claim.sequence))
+    ) {
+      throw new Error('Invalid hydration claim');
+    }
+  }
+  const result = structuredClone(value);
+  if (result.schema === 1) {
+    result.schema = HYDRATION_SCHEMA;
+    if (result.shift) {
+      result.shift.quietUntil = 0;
+      result.shift.recentActions = [];
+      result.shift.claim = null;
+      result.shift.sequence++;
+      if (!Number.isSafeInteger(result.shift.sequence))
+        throw new Error('Invalid hydration sequence');
+    }
+  }
+  return result;
+}
+
+export function hydrationContext(settings, clock) {
+  if (!settings || !clock || !Number.isFinite(clock.elapsed) || !Number.isFinite(clock.total))
+    return null;
+  return {
+    id: JSON.stringify([settings.timezone, clock.shiftDate]),
+    config: JSON.stringify([
+      settings.timezone,
+      settings.start,
+      settings.end,
+      settings.breakStart,
+      settings.breakEnd,
+      [...settings.weekdays].sort(),
+    ]),
+    schedule: JSON.stringify([
+      settings.start,
+      settings.end,
+      settings.breakStart,
+      settings.breakEnd,
+      [...settings.weekdays].sort(),
+      clock.shiftStart,
+      clock.shiftEnd,
+    ]),
+    status: clock.status,
+    end: clock.shiftEnd,
+    elapsed: Math.max(0, Math.floor(clock.elapsed * 1000)),
+    total: Math.max(0, Math.floor(clock.total * 1000)),
+  };
+}
+
+export function reconcileHydration(state, context, manual = false) {
+  const next = structuredClone(state);
+  if (!context) return next;
+  if (!next.enabled && !manual) {
+    if (next.shift) next.shift.claim = null;
+    return next;
+  }
+  if (next.shift?.id !== context.id) {
+    // Do not discard the last shift's count on a day off. New working shifts
+    // are initialized once the user opens the page, never backfilled.
+    if (!['before', 'working', 'lunch'].includes(context.status)) return next;
+    next.shift = {
+      id: context.id,
+      schedule: context.schedule,
+      config: context.config,
+      count: 0,
+      paused: false,
+      due: context.elapsed + next.interval * 60000,
+      sequence: 0,
+      claim: null,
+      quietUntil: 0,
+      recentActions: [],
+    };
+  } else if (next.shift.schedule !== context.schedule) {
+    next.shift.schedule = context.schedule;
+    next.shift.config = context.config;
+    next.shift.due = context.elapsed + next.interval * 60000;
+    next.shift.sequence++;
+    next.shift.claim = null;
+    next.shift.quietUntil = Math.min(next.shift.quietUntil, context.end);
+  }
+  if (next.shift && (!next.enabled || context.status !== 'working')) next.shift.claim = null;
+  return next;
+}
+
+export function hydrationView(state, context, now = 0) {
+  const same =
+    context && state.shift?.id === context.id && state.shift.schedule === context.schedule;
+  const shift = same ? state.shift : null;
+  const count = shift?.count ?? 0;
+  const remaining = shift ? Math.max(0, shift.due - context.elapsed) : state.interval * 60000;
+  const eventId = shift
+    ? JSON.stringify([shift.id, shift.schedule, shift.sequence, shift.due])
+    : null;
+  const quietRemaining =
+    shift && ['working', 'lunch'].includes(context.status)
+      ? Math.max(0, Math.min(shift.quietUntil, context.end) - now)
+      : 0;
+  let phase = 'waiting';
+  if (!state.enabled) phase = 'off';
+  else if (shift?.paused) phase = 'paused';
+  else if (quietRemaining > 0) phase = 'quiet';
+  else if (context?.status === 'lunch') phase = 'break';
+  else if (shift && context.status === 'working') {
+    phase = remaining === 0 ? 'due' : shift.due >= context.total ? 'finished' : 'countdown';
+  }
+  return { phase, count, remaining, eventId, quietRemaining };
+}
+
+export function transitionHydration(state, context, action, now, owner) {
+  if (!Number.isSafeInteger(now) || now < 0) throw new Error('Invalid reminder time');
+  // Reconfiguration requires an explicit compare-and-set grant obtained before
+  // reading/saving Host settings. A stale tab may release its lease or disable
+  // reminders, but cannot silently restore its previous schedule.
+  if (
+    context &&
+    state.shift &&
+    (state.shift.config !== context.config ||
+      (state.shift.id === context.id && state.shift.schedule !== context.schedule)) &&
+    action.baseSchedule !== state.shift.schedule
+  )
+    context = null;
+  const manual =
+    action.type === 'manual-drink' &&
+    action.shiftId === context?.id &&
+    ['working', 'lunch'].includes(context?.status);
+  let next = reconcileHydration(state, context, manual);
+  const restart = () => {
+    if (!next.shift || !context || next.shift.id !== context.id) return;
+    next.shift.due = context.elapsed + next.interval * 60000;
+    next.shift.sequence++;
+    next.shift.claim = null;
+  };
+  if (action.type === 'reset') return defaultHydration();
+  if (action.type === 'preferences') {
+    const enabled = Object.hasOwn(action, 'enabled') ? action.enabled : next.enabled;
+    const interval = Object.hasOwn(action, 'interval') ? action.interval : next.interval;
+    if (
+      typeof enabled !== 'boolean' ||
+      !Number.isInteger(interval) ||
+      interval < 5 ||
+      interval > 240
+    )
+      throw new Error('Invalid reminder preferences');
+    const changed = next.enabled !== enabled || next.interval !== interval;
+    next.enabled = enabled;
+    next.interval = interval;
+    next = reconcileHydration(next, context);
+    if (!next.enabled && next.shift) {
+      next.shift.claim = null;
+      next.shift.quietUntil = 0;
+    }
+    if (changed) restart();
+    return next;
+  }
+  const shift = next.shift;
+  if (action.type === 'release') {
+    if (shift?.claim?.owner === owner) shift.claim = null;
+    return next;
+  }
+  if (!shift || !context || shift.id !== context.id) return next;
+  if (shift.quietUntil && (now >= shift.quietUntil || now >= context.end)) shift.quietUntil = 0;
+  const view = hydrationView(next, context, now);
+  const validClaim =
+    shift.claim &&
+    shift.claim.owner === owner &&
+    shift.claim.sequence === shift.sequence &&
+    shift.claim.until > now &&
+    shift.claim.until <= now + HYDRATION_LEASE_MS;
+  if (action.type === 'manual-drink' && manual) {
+    if (
+      typeof action.actionId !== 'string' ||
+      !action.actionId.length ||
+      action.actionId.length > 128
+    )
+      throw new Error('Invalid hydration action id');
+    if (
+      shift.recentActions.includes(action.actionId) ||
+      (action.eventId !== undefined && action.eventId !== view.eventId)
+    )
+      return next;
+    shift.recentActions = [
+      ...shift.recentActions.slice(-(HYDRATION_ACTION_LIMIT - 1)),
+      action.actionId,
+    ];
+    shift.count = Math.min(1000000, shift.count + 1);
+    if (next.enabled && !shift.paused) restart();
+    else {
+      shift.sequence++;
+      shift.claim = null;
+    }
+  } else if (
+    action.type === 'quiet' &&
+    next.enabled &&
+    !shift.paused &&
+    ['working', 'lunch'].includes(context.status)
+  ) {
+    if (![30, 60].includes(action.minutes)) throw new Error('Invalid quiet duration');
+    shift.quietUntil = Math.min(now + action.minutes * 60000, context.end);
+    shift.claim = null;
+    shift.sequence++;
+  } else if (action.type === 'end-quiet' && shift.quietUntil) {
+    shift.quietUntil = 0;
+    shift.claim = null;
+    shift.sequence++;
+  } else if (action.type === 'claim' && view.phase === 'due') {
+    const claim = shift.claim;
+    if (
+      !claim ||
+      claim.owner === owner ||
+      claim.until <= now ||
+      claim.until > now + HYDRATION_LEASE_MS
+    ) {
+      shift.claim = { owner, until: now + HYDRATION_LEASE_MS, sequence: shift.sequence };
+    }
+  } else if (action.type === 'clear-count') {
+    shift.count = 0;
+  } else if (action.type === 'pause' && next.enabled && !shift.paused) {
+    shift.paused = true;
+    shift.quietUntil = 0;
+    shift.claim = null;
+    shift.sequence++;
+  } else if (action.type === 'resume' && next.enabled && shift.paused) {
+    shift.paused = false;
+    restart();
+  } else if (
+    ['drink', 'snooze'].includes(action.type) &&
+    view.phase === 'due' &&
+    validClaim &&
+    action.eventId === view.eventId
+  ) {
+    if (action.type === 'drink') shift.count = Math.min(1000000, shift.count + 1);
+    shift.due = context.elapsed + (action.type === 'snooze' ? 10 : next.interval) * 60000;
+    shift.sequence++;
+    shift.claim = null;
+  }
+  return next;
+}

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Offwork Clock",
-    "description": "A draggable countdown to clock-out with live estimated earnings and salary settings."
+    "description": "A Harness character companion with a clock-out countdown, estimated earnings, hydration reminders, quiet time and independent feature cards."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "下班计时器",
-    "description": "可拖动的下班倒计时与工资悬浮窗，支持月薪/日薪、夜班、工作日、可选休息扣除、金额隐藏与位置记忆。"
+    "description": "Harness 页面陪伴角色、下班倒计时、实时收入和喝水提醒，支持鲸系少女外观、免打扰、独立功能卡片与隐私偏好。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-offwork",
-  "version": "1.0.1",
-  "description": "下班倒计时与实时工资悬浮窗：可拖动、可调透明度、工资可隐藏。A draggable countdown and salary overlay for DeepSeek Harness.",
+  "version": "1.1.0",
+  "description": "Harness 页面陪伴角色、下班倒计时、实时收入与喝水提醒。Character companion, clock-out countdown, earnings and hydration reminders for DeepSeek Harness.",
   "type": "module",
   "license": "MIT",
   "author": "now",
@@ -38,9 +38,16 @@
     "client.source.js",
     "clock.js",
     "ui-utils.js",
+    "companion.js",
+    "pet-view.js",
+    "pet-interactions.js",
+    "pet-surfaces.js",
+    "hydration.js",
+    "hydration-store.js",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
+    "assets/characters/*",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",
@@ -70,6 +77,7 @@
     }
   },
   "devDependencies": {
+    "fake-indexeddb": "6.2.7",
     "prettier": "3.9.10"
   }
 }