dsh-plugin-vrmpet3d 0.1.0 → 0.1.2

package/lib/core.js

@@ -71,16 +71,32 @@
    * The `{duration}` token and its machinery stay — a line the user writes may still carry it (see
    * {@link STATUS_DURATION_TOKEN}) — but the shipped line is DSH's token-free 「深度求索中 ···」, which is also what the
    * app shows while the latest turn is not open.
+   *
+   * ONE TABLE PER LANGUAGE, keyed state → language, the same shape `SPEECH_LINES` uses for its pools and for the
+   * same reason: a status line is TEXT THE USER READS, so an interface in English that still said 「任务达成」 would
+   * be a half-translated one. The two halves are written rather than translated word for word, and the Chinese is
+   * the operator's own wording, unchanged since 2026-10-13.
+   *
+   * An EDIT wins over both: `statusEntryFor` only reaches for these while the user's own box is empty, so a line
+   * typed by hand is one line in one language and stays exactly that, in either interface language. That is the
+   * whole reason this is a per-language DEFAULT rather than a second field in the settings.
    */
   var DEFAULT_STATUS_TEXT = {
-    resting: '',
-    working: '深度求索中 ···',
-    waiting: '我有问题要问你',
-    done: '任务达成',
-    error: '遇到问题了...',
-    offline: '',
+    resting: { zh: '', en: '' },
+    working: { zh: '深度求索中 ···', en: 'Working ···' },
+    waiting: { zh: '我有问题要问你', en: 'I have a question for you' },
+    done: { zh: '任务达成', en: 'Task complete' },
+    error: { zh: '遇到问题了...', en: 'Something went wrong...' },
+    offline: { zh: '', en: '' },
   };
 
+  /** One state's shipped line in one language; `''` for a state that says nothing by default. */
+  function defaultStatusText(state, language) {
+    var entry = DEFAULT_STATUS_TEXT[state];
+    if (!entry || typeof entry !== 'object') return '';
+    return typeof entry[language === 'en' ? 'en' : 'zh'] === 'string' ? entry[language === 'en' ? 'en' : 'zh'] : '';
+  }
+
   /**
    * The token a status line may carry where the live elapsed time goes, and the units it is written with.
    *
@@ -96,6 +112,155 @@
     en: { hour: 'h ', minute: 'm ', second: 's' },
   };
 
+  /**
+   * The three answers to 「界面语言」, and the ONE rule that turns them into the language a surface draws in.
+   *
+   * `auto` is the shipped answer and means "whatever the surface is already running in": DSH's own locale inside
+   * the app, the browser's on a host-served page, and on a surface that can see neither (a suite, a headless
+   * host) English — the plugin's own fallback rather than a guess about the operator.
+   *
+   * The other two are the user overruling that, and they exist because the two questions are NOT the same one:
+   * DSH can be running in English while its owner wants the pet in Chinese, and the first-run guide is read once,
+   * before any of that has settled. Operator, 2026-10-15: 「把全部界面做中英双语自动识别，并在通用设置和初始安装
+   * 引导页的第一页欢迎页面中加上语言选择」.
+   *
+   * `auto` is STORED as `auto`, never resolved on write. A profile that stored the resolved 'zh' would freeze the
+   * language on the day it was created, and the user who later switched DSH to English would keep a Chinese pet
+   * with no way to tell that from a deliberate choice — the same mistake `DEFAULTS.petSurface` documents for
+   * 显示位置, and it is why this is a preference the CLEANER knows about rather than a value a page writes.
+   */
+  var LANGUAGE_SETTINGS = ['auto', 'zh', 'en'];
+
+  /** `'auto'` for anything that is not one of the three — an unknown stored value is a reset, not an error. */
+  function cleanLanguage(value) {
+    return LANGUAGE_SETTINGS.indexOf(value) === -1 ? 'auto' : value;
+  }
+
+  /**
+   * Which of the two languages this surface draws in, given the user's setting and what the environment says.
+   *
+   * `hints` is a LIST, most authoritative first — DSH's locale, then the document's own `lang`, then
+   * `navigator.language` — and the FIRST hint that says anything decides. That order is the rule and not a detail:
+   * DSH is the application the pet lives inside, so its language outranks the browser's, and a page DSH has
+   * already marked `lang="zh"` outranks a browser whose own preference is en-US.
+   *
+   * The first hint decides the ZH-or-not question instead of the chain continuing past it, because this plugin has
+   * exactly two languages. A hint of `fr` is not a reason to go looking for a Chinese one further down the chain;
+   * it is a reason to fall back to English, which is also what `auto` with nothing to go on means.
+   */
+  function resolveLanguage(preference, hints) {
+    var wanted = cleanLanguage(preference);
+    if (wanted !== 'auto') return wanted;
+    var list = Array.isArray(hints) ? hints : [hints];
+    for (var i = 0; i < list.length; i += 1) {
+      var hint = list[i];
+      if (typeof hint !== 'string' || !hint) continue;
+      return /^(zh|cn|chinese)/i.test(hint.trim()) ? 'zh' : 'en';
+    }
+    return 'en';
+  }
+
+  /**
+   * The environment's own two hints, in the order they outrank each other — what a surface that has no DSH locale
+   * to ask uses. `scope` exists so a suite can hand in a fake window instead of moving the real one.
+   *
+   * The BROWSER comes first, and the document's own `lang` second, which is the opposite of the order the app's
+   * widget uses — deliberately. Every page this plugin serves ships `<html lang="zh">` (the plugin was written in
+   * Chinese), so a page that read its own markup first could never be auto-detected as English: the hint would be
+   * its own default rather than anything about the user. `navigator.language` is the browser's answer and in the
+   * floating window it is Electron's, i.e. the machine's.
+   */
+  function browserLanguageHints(scope) {
+    var win = scope || (typeof globalThis !== 'undefined' ? globalThis : null);
+    var doc = win && win.document;
+    var nav = win && win.navigator;
+    return [
+      nav ? (nav.language || (nav.languages && nav.languages[0])) : null,
+      doc && doc.documentElement ? doc.documentElement.lang : null,
+    ];
+  }
+
+  /**
+   * One surface's own wording, in the two languages, chosen by {@link resolveLanguage}.
+   *
+   * Every surface keeps its OWN table — `lib/menu.js`'s `LABELS`, `lib/model-picker.js`'s `TEXT`, the settings
+   * pages' `TEXT` — rather than one global dictionary, because that is already this repository's shape (a surface
+   * owns the words it draws) and because a single table for six surfaces would make every one of them edit the
+   * same file. What IS shared is the SHAPE: `{ zh: {...}, en: {...} }`, this accessor, and {@link applyI18n}.
+   *
+   * A language half that is missing or empty falls back to the other one rather than to blank: a half-translated
+   * surface reads as Chinese in one spot, which is a bug somebody reports, where a blank label is a page that
+   * looks broken. `textOf` below is what makes a GAP visible, and a suite is what keeps one from shipping.
+   */
+  function textFor(table, language) {
+    if (!table || typeof table !== 'object') return {};
+    var wanted = language === 'en' ? table.en : table.zh;
+    var other = language === 'en' ? table.zh : table.en;
+    if (wanted && typeof wanted === 'object') return wanted;
+    return other && typeof other === 'object' ? other : {};
+  }
+
+  /** One entry out of a surface's table. A missing key returns the KEY, so a gap is visible on screen. */
+  function textOf(table, language, key) {
+    var value = textFor(table, language)[key];
+    return typeof value === 'string' ? value : key;
+  }
+
+  /**
+   * Fill a document's marked-up text from one surface's table.
+   *
+   * The markup carries the CHINESE text as well as the key, and that is on purpose: this plugin's pages all ship a
+   * bootstrap watchdog for the case where a script never ran, so a page whose script DID not run should still say
+   * something in one language rather than show nothing. `verify-desktop.mjs` asserts the two agree, which is what
+   * stops the markup and the table from drifting apart.
+   *
+   * Four attributes, one per place text lives: `data-i18n` writes `textContent`, `data-i18n-html` writes
+   * `innerHTML` and is for OUR OWN sentence with a `<strong>` in it (never for anything a user or a model wrote),
+   * and `data-i18n-placeholder` / `data-i18n-title` / `data-i18n-aria` write those three attributes.
+   *
+   * A key the table does not have leaves the markup ALONE rather than printing the key: the visible text stays the
+   * Chinese fallback, and the missing entry is the suite's business, not the user's.
+   *
+   * @returns {number} how many places were rewritten, so a suite can tell "applied nothing" from "no markup".
+   */
+  function applyI18n(root, table, language) {
+    var doc = root && typeof root.querySelectorAll === 'function'
+      ? root
+      : (typeof globalThis !== 'undefined' ? globalThis.document : null);
+    if (!doc || typeof doc.querySelectorAll !== 'function') return 0;
+    var words = textFor(table, language);
+    var selector = '[data-i18n],[data-i18n-html],[data-i18n-placeholder],[data-i18n-title],[data-i18n-aria]';
+    var nodes;
+    try {
+      nodes = doc.querySelectorAll(selector);
+    } catch (error) {
+      return 0;
+    }
+    var applied = 0;
+    var write = function (node, attribute, key, html) {
+      var value = words[key];
+      if (typeof value !== 'string') return;
+      if (attribute === 'data-i18n') node.textContent = value;
+      else if (html) node.innerHTML = value;
+      else node.setAttribute(attribute, value);
+      applied += 1;
+    };
+    for (var i = 0; i < nodes.length; i += 1) {
+      var node = nodes[i];
+      var key = node.getAttribute('data-i18n');
+      if (key) write(node, 'data-i18n', key, false);
+      key = node.getAttribute('data-i18n-html');
+      if (key) write(node, 'data-i18n-html', key, true);
+      key = node.getAttribute('data-i18n-placeholder');
+      if (key) write(node, 'placeholder', key, false);
+      key = node.getAttribute('data-i18n-title');
+      if (key) write(node, 'title', key, false);
+      key = node.getAttribute('data-i18n-aria');
+      if (key) write(node, 'aria-label', key, false);
+    }
+    return applied;
+  }
+
   /**
    * The states whose prompt carries DSH's whale mark.
    *
@@ -1014,9 +1179,8 @@
   }
 
   /**
-   * Which full-deflection distance to use: the SETTING when it is positive, otherwise the caller's own
-   * frame. Keeping that decision here rather than in each surface is what keeps "0 = 自动" meaning the
-   * same thing in the floating window (the screen's width) and in the app overlay (its window's width).
+   * A positive setting overrides automatic distance. Both axes and both surfaces
+   * pass the screen width here; automatic distance is half of that width.
    */
   function resolveGazeSpan(span, fallback) {
     var wanted = Number(span);
@@ -1024,7 +1188,7 @@
       return clamp(wanted, GAZE_SPAN_RANGE.min, GAZE_SPAN_RANGE.max);
     }
     var base = Number(fallback);
-    return isFiniteNumber(base) && base > 0 ? base : GAZE_SPAN.x;
+    return isFiniteNumber(base) && base > 0 ? base / 2 : GAZE_SPAN.x;
   }
 
   /**
@@ -1046,7 +1210,9 @@
    * Pure numbers, no DOM, so the logic suite covers the clamping and the signs.
    *
    * @param {{pointerX:number, pointerY:number, centreX:number, centreY:number,
-   *   spanX?:number, spanY?:number, curve?:number}} input
+   *   spanX?:number, spanY?:number, curve?:number, curveY?:number,
+   *   curveRadial?:number, curveSpatial?:number, distance?:number,
+   *   mode?:'axes'|'radial'|'spatial'}} input
    * @returns {{x:number, y:number}|null} `null` when the input is unusable; `y` is
    *   positive BELOW the pet, i.e. in screen coordinates
    */
@@ -1065,12 +1231,39 @@
       : GAZE_SPAN.y;
     // The settings' curve, unless the caller passes its own (the suite does, to pin a shape).
     var edgeSlope = isFiniteNumber(Number(input.curve)) ? Number(input.curve) : DEFAULTS.gazeCurve;
+    var slopeY = isFiniteNumber(Number(input.curveY)) ? Number(input.curveY) : edgeSlope;
+    if (input.mode === 'spatial') {
+      var spatialX = (pointerX - centreX) / spanX;
+      var spatialY = (pointerY - centreY) / spanY;
+      if (!isFiniteNumber(spatialX) || !isFiniteNumber(spatialY)) return null;
+      var depth = isFiniteNumber(Number(input.distance)) && Number(input.distance) > 0
+        ? clamp(Number(input.distance), 0.1, 5) : DEFAULTS.gazeDistance;
+      // A virtual target plane in span units: sideways distance reduces pitch
+      // at a fixed pointer height. Curves shape angles, rather than pixel offsets.
+      var yawAngle = Math.atan2(spatialX, depth) / (Math.PI / 2);
+      var pitchAngle = Math.atan2(spatialY, Math.hypot(spatialX, depth)) / (Math.PI / 2);
+      var spatialSlope = isFiniteNumber(Number(input.curveSpatial)) ? Number(input.curveSpatial) : DEFAULTS.gazeCurveSpatial;
+      return {
+        x: (yawAngle < 0 ? -1 : 1) * gazeCurve(Math.abs(yawAngle), spatialSlope),
+        y: (pitchAngle < 0 ? -1 : 1) * gazeCurve(Math.abs(pitchAngle), spatialSlope),
+      };
+    }
+    if (input.mode === 'radial') {
+      var dx = (pointerX - centreX) / spanX;
+      var dy = (pointerY - centreY) / spanY;
+      var distance = Math.hypot(dx, dy);
+      if (!isFiniteNumber(distance)) return null;
+      if (distance === 0) return { x: 0, y: 0 };
+      var radialSlope = isFiniteNumber(Number(input.curveRadial)) ? Number(input.curveRadial) : edgeSlope;
+      var gain = gazeCurve(Math.min(1, distance), radialSlope) / distance;
+      return { x: dx * gain, y: dy * gain };
+    }
     var rawX = clamp((pointerX - centreX) / spanX, -1, 1);
     var rawY = clamp((pointerY - centreY) / spanY, -1, 1);
     // Mirrored through `gazeCurve` so the sign survives and the response is the curve on both sides.
     return {
       x: rawX < 0 ? -gazeCurve(-rawX, edgeSlope) : gazeCurve(rawX, edgeSlope),
-      y: rawY < 0 ? -gazeCurve(-rawY, edgeSlope) : gazeCurve(rawY, edgeSlope)
+      y: rawY < 0 ? -gazeCurve(-rawY, slopeY) : gazeCurve(rawY, slopeY)
     };
   }
 
@@ -1080,6 +1273,12 @@
   /** Default pose and behaviour knobs. */
   var DEFAULTS = {
     scope: 'global',
+    /**
+     * 界面语言 — `auto` follows the surface's own environment ({@link resolveLanguage}), and 中文 / English overrule
+     * it. It sits first in the table rather than beside the appearance rows because it is the one preference that
+     * decides how every OTHER row is spelled.
+     */
+    language: 'auto',
     size: 100,
     /**
      * WHERE the pet is shown, as the cleaner's DEFAULT rather than a string repeated beside it.
@@ -1177,12 +1376,21 @@
      * operator's own (2026-10-13: 「视线：曲率设置默认为0.1，提供0.05-1的选择（原先是0.1-1），静止停看默认为2秒」).
      * `gazeCurve` is the curve's slope at the frame's edge — 1 is a straight line, smaller is a
      * steeper start and a flatter tail — and `gazeSpanX`/`gazeSpanY` are the full-deflection
-     * distances in CSS pixels, where **0 means AUTO**: the caller's own frame (the screen's width in
-     * the floating window, the window's width in the app overlay) and, vertically, the fallback below.
+     * distances in CSS pixels, where **0 means AUTO**: half the screen width on both axes.
+     * `gazeCurve` / `gazeCurveY` remain readable for older delivered clients; the current
+     * settings expose only spatial (default) and radial modes.
      */
     gazeCurve: 0.1,
+    gazeCurveMode: 'spatial',
+    gazeCurveY: 0.1,
+    gazeCurveRadial: 0.1,
+    gazeCurveSpatial: 1,
+    gazeDistance: 0.1,
     gazeSpanX: 0,
     gazeSpanY: 0,
+    // Actual head pitch in degrees, after the renderer's gaze weight.
+    gazePitchUp: 60,
+    gazePitchDown: 60,
     /**
      * How long the cursor may sit still before the pet stops following it, in seconds.
      *
@@ -1294,6 +1502,7 @@
      * not silently pin drag and gravity to the numbers the panel happened to be showing.
      */
     springs: {},
+    toon: {},
     /**
      * Per-model size multiplier for BOTH texts: `{ [modelId]: number }`.
      *
@@ -1925,6 +2134,13 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var out = {};
     var source = raw && typeof raw === 'object' ? raw : {};
     out.scope = source.scope === 'current' ? 'current' : 'global';
+    /**
+     * 界面语言 — cleaned like every other enumerated preference: an unknown value (an older profile, a typo, a page
+     * that sent the wrong thing) is `auto`, which resolves to the surface's own environment anyway. It is NOT
+     * counted as authorship by `authoredWeight` over in `lib/settings.js`: a language is a way of looking at the
+     * pet, not something the user wrote into it.
+     */
+    out.language = cleanLanguage(source.language);
     // An unknown surface falls back to the shipped default, not to a string repeated here.
     out.petSurface = PET_SURFACES.indexOf(source.petSurface) === -1 ? DEFAULTS.petSurface : source.petSurface;
     out.size = Number.isFinite(Number(source.size)) ? clamp(Number(source.size), SIZE_RANGE.min, SIZE_RANGE.max) : DEFAULTS.size;
@@ -2021,12 +2237,25 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     out.gazeCurve = Number.isFinite(Number(source.gazeCurve))
       ? clamp(Number(source.gazeCurve), GAZE_CURVE_RANGE.min, GAZE_CURVE_RANGE.max)
       : DEFAULTS.gazeCurve;
+    out.gazeCurveMode = source.gazeCurveMode === 'radial' ? 'radial' : 'spatial';
+    ['gazeCurveY', 'gazeCurveRadial'].forEach(function (key) {
+      out[key] = typeof source[key] === 'number' && Number.isFinite(source[key])
+        ? clamp(source[key], GAZE_CURVE_RANGE.min, GAZE_CURVE_RANGE.max) : DEFAULTS[key];
+    });
+    out.gazeCurveSpatial = typeof source.gazeCurveSpatial === 'number' && Number.isFinite(source.gazeCurveSpatial)
+      ? clamp(source.gazeCurveSpatial, GAZE_CURVE_RANGE.min, GAZE_CURVE_RANGE.max) : DEFAULTS.gazeCurveSpatial;
+    out.gazeDistance = typeof source.gazeDistance === 'number' && Number.isFinite(source.gazeDistance)
+      ? clamp(source.gazeDistance, 0.1, 5) : DEFAULTS.gazeDistance;
     out.gazeSpanX = Number.isFinite(Number(source.gazeSpanX))
       ? clamp(Number(source.gazeSpanX), GAZE_SPAN_RANGE.min, GAZE_SPAN_RANGE.max)
       : DEFAULTS.gazeSpanX;
     out.gazeSpanY = Number.isFinite(Number(source.gazeSpanY))
       ? clamp(Number(source.gazeSpanY), GAZE_SPAN_RANGE.min, GAZE_SPAN_RANGE.max)
       : DEFAULTS.gazeSpanY;
+    ['gazePitchUp', 'gazePitchDown'].forEach(function (key) {
+      out[key] = typeof source[key] === 'number' && Number.isFinite(source[key])
+        ? clamp(source[key], 0, 60) : DEFAULTS[key];
+    });
     // 0 is a legitimate value here — it turns the idle rule off — so this cannot fall back to the default the
     // way an unparseable value does. A negative number is unparseable for this purpose and becomes 0.
     out.gazeIdleSeconds = Number.isFinite(Number(source.gazeIdleSeconds))
@@ -2081,6 +2310,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       ? source.expressions.emotion.parts
       : null);
     out.springs = cleanSprings(source.springs);
+    out.toon = cleanToon(source.toon);
     return out;
   }
 
@@ -2091,6 +2321,25 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * directory's manifest says `loop: false`) has to be OVERRIDABLE back to looping, and "no entry" cannot
    * express that — absence means "ask the catalog".
    */
+  function cleanToon(raw) {
+    var out = {};
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+    Object.keys(raw).slice(0, 256).forEach(function (id) {
+      if (id === '__proto__' || id === 'constructor' || id === 'prototype') return;
+      var entry = raw[id];
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return;
+      var next = {};
+      if (typeof entry.enabled === 'boolean') next.enabled = entry.enabled;
+      var ranges = { shadingToonyFactor: [0, 1], shadingShiftFactor: [-1, 1], shadeStrength: [0, 1], outlineScale: [0, 3] };
+      Object.keys(ranges).forEach(function (key) {
+        var value = entry[key];
+        if (typeof value === 'number' && Number.isFinite(value)) next[key] = clamp(value, ranges[key][0], ranges[key][1]);
+      });
+      if (Object.keys(next).length) out[id] = next;
+    });
+    return out;
+  }
+
   function cleanMotionLoop(raw) {
     var out = {};
     var source = raw && typeof raw === 'object' ? raw : {};
@@ -2480,8 +2729,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
   // ---------------------------------------------------------------------------
 
   /** One state's status line, exactly as the renderer draws it: text, then the tag. */
-  function statusLineFor(preferences, state) {
-    var entry = statusEntryFor(preferences, state);
+  function statusLineFor(preferences, state, language) {
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry) return '';
     var tag = typeof entry.tag === 'string' ? entry.tag : '';
     return (entry.text + tag).slice(0, STATUS_LIMITS.textLength + STATUS_LIMITS.tagLength);
@@ -2493,11 +2742,15 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * Always an OBJECT, never null: every state has something to say or an explicit reason to say nothing,
    * and a caller that had to distinguish "unconfigured" from "configured empty" would get it wrong in the
    * one case that matters (a user who cleared a line).
+   *
+   * `language` picks WHICH shipped default fills an empty box — see {@link DEFAULT_STATUS_TEXT}. It is the third
+   * parameter and optional, so a caller that does not know the surface's language keeps the Chinese default the
+   * suites and the older call sites already pin.
    */
-  function statusEntryFor(preferences, state) {
+  function statusEntryFor(preferences, state, language) {
     var map = preferences && preferences.status && typeof preferences.status === 'object' ? preferences.status : {};
     var stored = map[state] && typeof map[state] === 'object' ? map[state] : {};
-    var fallback = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_TEXT, state) ? DEFAULT_STATUS_TEXT[state] : '';
+    var fallback = defaultStatusText(state, language);
     var text = typeof stored.text === 'string' ? stored.text : fallback;
     var fallbackAnimation = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_ANIMATION, state)
       ? DEFAULT_STATUS_ANIMATION[state]
@@ -3370,6 +3623,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * @returns {string|null} the line to show, or null for silence
    */
   SpeechMachine.prototype.observe = function (preferences, state, pendingKind, language, random, motion) {
+    if (state === 'dancing') {
+      this.current = null;
+      this.wantsAi = null;
+      this.lastEvent = null;
+      this.idleAt = null;
+      this.chatterAt = null;
+      return null;
+    }
     var speech = cleanSpeech(preferences && preferences.speech);
     var t = this.now();
     if (!speech.enabled) {
@@ -3626,11 +3887,17 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * clause is DROPPED — DSH's own token-free 「深度求索中」 rather than a number invented here. Passed per call so the
    * two surfaces (the app's pet and the floating window) can only differ by what they are told, never by the rule.
    *
+   * `language` is the SIXTH parameter and it reaches two places: which shipped default an empty box falls back to
+   * ({@link DEFAULT_STATUS_TEXT}), and the units a `{duration}` clause is written in — DSH writes 1分30秒 in one
+   * language and 1m 30s in the other, so a line translated without its clock would read as a foreign number.
+   * Optional, like the status-entry language above: a caller that has no language to pass keeps the Chinese answer
+   * every existing suite pins.
+   *
    * @returns {{state: string, text: string, tag: string, animation: string, seconds: number}|null}
    */
-  function statusFor(preferences, state, enteredAt, now, clock) {
+  function statusFor(preferences, state, enteredAt, now, clock, language, completedCount) {
     if (STATUS_STATES.indexOf(state) === -1) return null;
-    var entry = statusEntryFor(preferences, state);
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry.text && !entry.tag) return null;
     var at = Number.isFinite(now) ? now : Date.now();
     /**
@@ -3683,7 +3950,10 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
       text = elapsed === null
         ? durationClauseRemoved(text)
-        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed));
+        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed, language));
+    }
+    if (state === 'done' && Number(completedCount) > 1 && text) {
+      text = language === 'en' ? (text === 'Task complete' ? 'All tasks complete' : 'All ' + text) : '全部' + text;
     }
     var look = statusTone(state);
     return {
@@ -4718,6 +4988,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * @param {object} options url, intervalMs, fetchImpl, onPreview(preview|null), onUnsupported
    */
   function watchHostPreview(options) {
+    var navigationSeen = null;
     var settings = options || {};
     var url = settings.url || '/vrmpet3d/preview';
     // Four hundred milliseconds: this drives a hover preview, so it has to feel immediate, and the route is a
@@ -4726,11 +4997,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var doFetch = settings.fetchImpl || (typeof fetch === 'function' ? fetch : null);
     var timer = null;
     var seen = -1;
+    var issued = 0;
+    var delivered = 0;
     var supported = Boolean(doFetch);
     var stopped = false;
 
     function load() {
       if (!supported || stopped) return Promise.resolve(null);
+      var request = ++issued;
       return doFetch(url, { credentials: 'omit' })
         .then(function (response) {
           if (response.status === 404 || response.status === 405) {
@@ -4742,6 +5016,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
           return response.json ? response.json() : null;
         })
         .then(function (body) {
+          if (request < delivered) return null;
+          if (body && typeof body.seq === 'number') delivered = request;
+          if (body && body.navigation && typeof body.navigation.seq === 'number') {
+            var navigation = body.navigation;
+            if (navigationSeen !== null && navigationSeen !== navigation.seq && typeof navigation.sessionId === 'string'
+              && typeof settings.onNavigate === 'function') settings.onNavigate(navigation.sessionId);
+            navigationSeen = navigation.seq;
+          }
           if (!body || typeof body.seq !== 'number' || body.seq === seen) return null;
           seen = body.seq;
           var preview = cleanPreview(body.preview);
@@ -4879,11 +5161,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var doFetch = settings.fetchImpl || (typeof fetch === 'function' ? fetch : null);
     var timer = null;
     var seen = -1;
+    var issued = 0;
+    var delivered = 0;
     var supported = Boolean(doFetch);
     var stopped = false;
 
     function load() {
       if (!supported || stopped) return Promise.resolve(null);
+      var request = ++issued;
       return doFetch(url, { credentials: 'omit' })
         .then(function (response) {
           if (response.status === 404 || response.status === 405) {
@@ -4895,6 +5180,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
           return response.json ? response.json() : null;
         })
         .then(function (body) {
+          if (request < delivered) return null;
+          if (body && typeof body.seq === 'number') delivered = request;
           if (!body || typeof body.seq !== 'number' || body.seq === seen) return null;
           seen = body.seq;
           var state = STATES.indexOf(body.state) === -1 ? null : body.state;
@@ -5004,6 +5291,12 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
       if (typeof why.scope === 'string' && why.scope) out.scope = why.scope.slice(0, 16);
       if (typeof why.session === 'string' && why.session) out.session = why.session.slice(0, 64);
+      if (typeof why.statusSessionId === 'string' && why.statusSessionId) out.statusSessionId = why.statusSessionId.slice(0, 64);
+      if (typeof why.completedSessionId === 'string' && why.completedSessionId) out.completedSessionId = why.completedSessionId.slice(0, 64);
+      ['waitingSessionIds', 'completedSessionIds'].forEach(function (key) {
+        if (Array.isArray(why[key])) out[key] = why[key].filter(function (id) { return typeof id === 'string' && id; })
+          .slice(0, 256).map(function (id) { return id.slice(0, 64); });
+      });
       if (typeof why.interaction === 'string' && why.interaction) out.interaction = why.interaction.slice(0, 16);
       if (Array.isArray(why.runningIds)) {
         out.runningIds = why.runningIds
@@ -5161,15 +5454,19 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
        * its 进行中 line has to travel with the state. A whole number, or nothing — an older host that does not send it
        * leaves the window's dot as it was rather than inventing a count.
        */
-      var nextUnread = Number.isFinite(Number(unread)) && Number(unread) > 0 ? Math.floor(Number(unread)) : null;
+      var nextUnread = typeof unread === 'number' && Number.isFinite(unread) && unread >= 0 ? Math.floor(unread) : null;
       /**
        * The diagnostic, kept OUT of the change key on purpose: it carries counts and clock readings that move
        * constantly, and letting them force a report would turn "the pet announces a change" into a 1 Hz feed. It
        * rides along with the reports the state and the line already earn, and the heartbeat re-states the last one.
        */
       var nextWhy = cleanWhy(why);
+      var navigationKey = function (value) {
+        return JSON.stringify(value ? [value.waitingSessionIds || [], value.completedSessionIds || [],
+          value.statusSessionId || null, value.completedSessionId || null] : [[], [], null, null]);
+      };
       if (force !== true && next === sent && nextLine === sentLine && nextTouchKey === sentTouchKey
-        && nextClockKey === sentClockKey && nextUnread === sentUnread) {
+        && nextClockKey === sentClockKey && nextUnread === sentUnread && navigationKey(nextWhy) === navigationKey(sentWhy)) {
         return Promise.resolve(null);
       }
       sent = next;
@@ -5294,10 +5591,15 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var doFetch = settings.fetchImpl || (typeof fetch === 'function' ? fetch : null);
     var timer = null;
     var seen = -1;
+    var issued = 0;
+    var delivered = 0;
     var supported = Boolean(doFetch);
     var stopped = false;
 
-    function deliver(snapshot) {
+    function deliver(snapshot, request) {
+      // A slow poll/write must not roll a live gesture back to an older reply.
+      if (request < delivered) return null;
+      if (snapshot && typeof snapshot.version === 'number') delivered = request;
       if (!snapshot || typeof snapshot.version !== 'number' || snapshot.version === seen) return null;
       seen = snapshot.version;
       if (typeof settings.onSnapshot === 'function') settings.onSnapshot(snapshot);
@@ -5307,6 +5609,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     /** One look at the host. Returns a promise for the snapshot it delivered, if any. */
     function load() {
       if (!supported || stopped) return Promise.resolve(null);
+      var request = ++issued;
       return doFetch(url, { credentials: 'omit' })
         .then(function (response) {
           if (response.status === 404 || response.status === 405) {
@@ -5318,7 +5621,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
           if (!response.ok) return null;
           return response.json ? response.json() : null;
         })
-        .then(deliver)
+        .then(function (snapshot) { return deliver(snapshot, request); })
         .catch(function () { return null; });
     }
 
@@ -5330,6 +5633,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      */
     function push(body) {
       if (!supported || stopped) return Promise.resolve(null);
+      var request = ++issued;
       return doFetch(url, {
         method: 'POST',
         credentials: 'omit',
@@ -5337,7 +5641,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
         body: JSON.stringify(body || {}),
       })
         .then(function (response) { return response.ok ? response.json() : null; })
-        .then(deliver)
+        .then(function (snapshot) { return deliver(snapshot, request); })
         .catch(function () { return null; });
     }
 
@@ -5550,6 +5854,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * sits above the watermark and is adopted as usual.
      */
     this.dismissedNoticeAt = 0;
+    this.dismissedSessions = new Map();
     /**
      * The TURN the pet is currently describing, and the one that just ended.
      *
@@ -5832,6 +6137,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
   PetMachine.prototype.dismissNotice = function (keepDebt) {
     if (this.notice && Number.isFinite(this.notice.at)) {
       this.dismissedNoticeAt = Math.max(this.dismissedNoticeAt, this.notice.at);
+      if (this.notice.sessionId) this.dismissedSessions.set(this.notice.sessionId, this.notice.at);
     }
     if (keepDebt !== true && this.notice && this.notice.sessionId) {
       delete this.retractions[this.notice.sessionId];
@@ -5954,7 +6260,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
        * well as in the acknowledgement rule in `resolve`. (The floating window never takes focus, which is why the same
        * drag could not do this there.)
        */
-      if (this.notice && (!this.notice.sessionId || !presenceKnown) && this.interaction === null) {
+      if (this.notice && !this.notice.sessionId && !presenceKnown && this.interaction === null) {
         this.noteDismissal('focus-return');
         this.dismissNotice();
       }
@@ -6066,6 +6372,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
             // reports as its own `at`, so the minimum hold starts when the user can first see it.
             endedAt: at,
             settledAt: this.now(),
+            confirmed: payload.confirmed === true,
             sessionId: sessionId,
           };
         }
@@ -6091,8 +6398,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * than a startup that has not finished.
      */
     if (snap.connected === true) this.everConnected = true;
-    var busy = snap.available === true && (snap.running === true || snap.pending === true);
+    var busy = snap.pending === true || (snap.available === true && snap.running === true);
     if (busy) this.lastBusyAt = t;
+    var viewedCompletions = Array.isArray(snap.viewedCompletions) ? snap.viewedCompletions : [];
+    if (this.pendingNotice && viewedCompletions.indexOf(this.pendingNotice.sessionId) !== -1) this.pendingNotice = undefined;
+    if (this.notice && viewedCompletions.indexOf(this.notice.sessionId) !== -1) {
+      this.noteDismissal('acknowledged');
+      this.dismissNotice();
+    }
 
     /**
      * Adopt the SNAPSHOT's own notice when it is newer than this machine's.
@@ -6111,9 +6424,11 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * what the aggregate watches, and it falls between the rounds of one task exactly like a turn does.
      */
     if (snap.notice && typeof snap.notice.at === 'number'
-      && snap.notice.at > this.dismissedNoticeAt
-      && (!this.notice || snap.notice.at > this.notice.at)
-      && (!this.pendingNotice || snap.notice.at > this.pendingNotice.endedAt)) {
+      && (snap.notice.queued === true ? (!this.notice && !this.pendingNotice
+          && (!this.dismissedSessions.has(snap.notice.sessionId) || snap.notice.at > this.dismissedSessions.get(snap.notice.sessionId)))
+        : (snap.notice.at > this.dismissedNoticeAt
+          && (!this.notice || snap.notice.at > this.notice.at)
+          && (!this.pendingNotice || snap.notice.at > this.pendingNotice.endedAt)))) {
       var snapSession = typeof snap.notice.sessionId === 'string' && snap.notice.sessionId ? snap.notice.sessionId : null;
       if (snap.notice.reason === 'error') {
         // A failure is not a completion and is never settled: it is shown at once, exactly as a `turn/end` failure is.
@@ -6123,7 +6438,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
         this.pendingNotice = {
           reason: snap.notice.reason,
           endedAt: snap.notice.at,
-          settledAt: t,
+          settledAt: snap.notice.queued === true ? snap.notice.at : t,
+          confirmed: snap.notice.confirmed === true,
           // The session the notice is ABOUT. Without it there is nothing to come back to, and the notice falls
           // back to the older focus/timer rules below.
           sessionId: snapSession,
@@ -6139,6 +6455,9 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * (a `turn/end` frame and the store's falling edge) are decided together.
      */
     if (this.pendingNotice) {
+      if (snap.notice && snap.notice.sessionId === this.pendingNotice.sessionId && snap.notice.confirmed === true) {
+        this.pendingNotice.confirmed = true;
+      }
       var pendingSession = this.pendingNotice.sessionId;
       /**
        * Cancelled by WORK RESUMING, and only that — the ordering is the whole point.
@@ -6161,7 +6480,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
          * never produced one.
          */
         this.pendingNotice = undefined;
-      } else if (t - this.pendingNotice.settledAt >= this.settleFor(this.pendingNotice.sessionId)) {
+      } else if (this.pendingNotice.confirmed || t - this.pendingNotice.settledAt >= this.settleFor(this.pendingNotice.sessionId)) {
         this.notice = {
           reason: this.pendingNotice.reason,
           // Visible from NOW: the settle window was spent waiting, and a hold measured from the turn's end would
@@ -6237,8 +6556,10 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
        */
       var unreadDropped = isFiniteNumber(this.unreadAtNotice) && this.unreadCount < this.unreadAtNotice;
       var neverUnread = this.unreadAtNotice === 0 && this.unreadCount === 0;
-      acknowledged = notice.sessionId && presentId
-        ? (presentId === notice.sessionId && this.focused === true)
+      var viewed = Array.isArray(snap.viewedCompletions) && snap.viewedCompletions.indexOf(notice.sessionId) !== -1;
+      acknowledged = notice.sessionId
+        ? (viewed || ((!this.requireViewedAcknowledgement || notice.reason !== 'completed')
+          && presentId === notice.sessionId && this.focused === true))
         : (notice.reason !== 'error' && this.focused === true
           && (unreadDropped || (neverUnread && this.interaction === null)));
       this.pendingDismissalKind = notice.sessionId && presentId ? 'acknowledged' : 'no-session';
@@ -6260,8 +6581,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * still on screen would flip the pet to 出错 and hide the very prompt the user has to answer, and a
      * turn that completes would show 任务达成 over an unanswered approval.
      *
-     * So while the session reports a pending interaction, EVERY other branch is skipped except the two the
-     * user owns by hand (a drag, and a click they just made). When the interaction is answered the session
+     * While the session reports a pending interaction, EVERY other state is skipped, including gestures
+     * and greetings. When the interaction is answered the session
      * stops reporting it, this latch releases, and the same frame's cascade decides where the pet goes.
      */
     var pending = snap.pending === true;
@@ -6288,7 +6609,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     /**
      * 跳舞 — the user's own state, and the two rules that make it a good guest (operator, 2026-10-14).
      *
-     * It sits here, AFTER the drag states and BEFORE greeting/waiting/offline — so a drag still owns the pet while it happens —
+     * Attention comes first, followed by drag states, dance, greeting and offline.
      * and it is dropped the moment the session is BUSY, which is the operator's 「跳舞也会被进入工作状态打断」 without a rule of its
      * own: work outranks it because the busy branch below is reached first once this field is cleared. A dance also ends when the
      * clip ends (the client watches the clip and calls `stopDancing`) or when the user double-clicks the pet, and both of those
@@ -6299,14 +6620,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       this.stopDancing();
       dance = null;
     }
-    if (this.interaction) {
+    if (pending) {
+      state = 'waiting';
+    } else if (this.interaction) {
       state = this.interaction;
     } else if (dance) {
       state = 'dancing';
     } else if (t < this.greetingUntil) {
       state = 'greeting';
-    } else if (pending) {
-      state = 'waiting';
     } else if (snap.connected === false && this.everConnected) {
       /**
        * 离线 means the host is GONE — not that it has nothing to say yet.
@@ -6406,6 +6727,11 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     this.records = new Map();
     /** Each session's own `running` flag as the store last reported it (see `observeStoreEdge`). */
     this.storeRunning = new Map();
+    this.completionChecks = new Map();
+    this.attentionSessions = new Map();
+    this.completionQueue = new Map();
+    this.completionSeen = new Set();
+    this.viewedCompletions = new Set();
     /**
      * When this aggregate's `running` answer last became true, and what it was last published as.
      *
@@ -6465,6 +6791,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       var status = statuses && statuses.get ? statuses.get(id) : undefined;
       var running = status && typeof status.running === 'boolean' ? status.running : undefined;
       if (running === undefined) return;
+      if (running || status.pendingInteraction != null) self.completionChecks.delete(id);
+      if (running) self.forgetCompletion(id);
       var previous = self.storeRunning.get(id);
       self.storeRunning.set(id, running);
       if (previous === running) return;
@@ -6488,13 +6816,18 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
        * stream covers that case when it is wired, and a false 任务完成 on every boot is worse than a missed one.
        */
       if (previous !== true) return;
+      var boundaryRecord = self.records.get(id);
+      if (boundaryRecord && boundaryRecord.lastEndReason && boundaryRecord.lastEndReason !== 'completed') return;
       // Stopped: a completion. A failure already latched outranks it, the same rule the boundary path uses.
+      var completion = { id: id + ':store', reason: 'completed', sessionId: id, at: self.now() };
+      self.rememberCompletion(completion);
       if (self.notice && self.notice.reason === 'error') return;
-      self.notice = { id: id + ':store', reason: 'completed', sessionId: id, at: self.now() };
+      self.notice = completion;
     });
   };
 
   SessionAggregate.prototype.reset = function (identities) {
+    this.completionChecks.clear();
     this.records.clear();
     this.notice = undefined;
     if (Array.isArray(identities)) {
@@ -6508,6 +6841,34 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     }
   };
 
+  SessionAggregate.prototype.rememberCompletion = function (notice, announce) {
+    var id = notice && notice.sessionId;
+    if (!id || this.completionSeen.has(id)) return;
+    this.completionSeen.add(id);
+    this.completionQueue.set(id, Object.assign({}, notice, {
+      announce: announce !== false, queued: true, confirmed: announce !== false,
+    }));
+    this.completionChecks.set(id, this.now());
+  };
+
+  SessionAggregate.prototype.forgetCompletion = function (id) {
+    this.completionQueue.delete(id);
+    this.completionChecks.delete(id);
+    this.completionSeen.delete(id);
+    this.viewedCompletions.delete(id);
+  };
+
+  SessionAggregate.prototype.acknowledgeViewed = function (id) {
+    if (!id || this.running(id) !== false) return;
+    var status = this.input.statuses.get ? this.input.statuses.get(id) : null;
+    if (!this.completionQueue.has(id) && !(status && status.completionUnread === true)) return;
+    this.completionSeen.add(id);
+    this.viewedCompletions.add(id);
+    this.completionQueue.delete(id);
+    this.completionChecks.delete(id);
+    if (this.notice && this.notice.sessionId === id && this.notice.reason === 'completed') this.notice = undefined;
+  };
+
   SessionAggregate.prototype.boundary = function (event) {
     if (!event || typeof event !== 'object') return this.snapshot();
     var id = event.sessionId;
@@ -6534,12 +6895,16 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     // The host's live answer for a session it vouches for: every root it classified arrives as `false`.
     if (event.isSubagent === false) record.isSubagent = false;
     if (event.type === 'turn/start') {
+      this.forgetCompletion(id);
       record.running = true;
+      record.lastEndReason = null;
+      this.completionChecks.delete(id);
       record.candidate = undefined;
       // A new turn supersedes whatever the last one reported, error included.
       this.notice = undefined;
     } else if (event.type === 'turn/end') {
       record.running = false;
+      record.lastEndReason = event.reason;
       record.candidate = { id: id + ':' + event.seq, reason: event.reason, at: this.now() };
     }
     this.records.set(id, record);
@@ -6549,7 +6914,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * a frame for a session nobody can vouch for — not classified, not listed by the app — is silence rather than a
      * 任务达成, because the pet has no way to tell it from a helper's turn ending (2026-10-14).
      */
-    if (candidate && (candidate.reason === 'completed' || record.running === false) && this.mainSession(id)) {
+    if (candidate && (candidate.reason === 'completed' || candidate.reason === 'error') && this.mainSession(id)) {
+      if (candidate.reason === 'completed') this.rememberCompletion({ id: candidate.id, reason: candidate.reason, sessionId: id, at: candidate.at });
       record.candidate = undefined;
       // A failure latches: a success arriving moments later must not erase the
       // fact that a turn just died. The machine owns the same rule, so the two
@@ -6570,6 +6936,19 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
   };
 
   SessionAggregate.prototype.subagent = function (id) {
+    var list = this.input.catalog || {};
+    var row = list.byId && list.byId[id];
+    // The current DSH store publishes origin and its parents' subagent catalogs, not isSubagent.
+    // These explicit identities outrank an older boundary baseline that called the agent a root.
+    if (row && (row.origin === 'subagent' || row.isSubagent === true)) return true;
+    var parents = Object.keys(list.byId || {});
+    for (var p = 0; p < parents.length; p += 1) {
+      var parent = list.byId[parents[p]];
+      var projection = list.projectionsBySession && list.projectionsBySession[parents[p]];
+      var values = (projection && projection.values) || (parent && parent.projectionValues);
+      var children = values && values.subagentCatalog;
+      if (Array.isArray(children) && children.some(function (child) { return child && child.id === id; })) return true;
+    }
     var record = this.records.get(id);
     if (record && record.isSubagent !== undefined) return record.isSubagent === true;
     var catalog = this.input.catalog && this.input.catalog.byId ? this.input.catalog.byId[id] : undefined;
@@ -6651,7 +7030,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * only ever make the answer STRICTER on a store that has the list.
      */
     var listed = catalog.ids;
-    if (listed && typeof listed.length === 'number' && listed.length > 0) {
+    if (listed && typeof listed.length === 'number') {
       for (var i = 0; i < listed.length; i += 1) {
         if (listed[i] === id) return true;
       }
@@ -6669,6 +7048,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
 
     var workingCount = 0;
     var waitingCount = 0;
+    var waitingSessionId = null;
     /**
      * How many sessions have a completion the user has NOT been back to.
      *
@@ -6685,6 +7065,9 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
      * contributes nothing.
      */
     var unreadCount = 0;
+    var completedUnreadCount = 0;
+    var completedSessionId = null;
+    var completedSessionIds = [];
     /**
      * WHY that count is what it is, as counts rather than ids or titles — added with the 绿点 fix of 2026-10-14, so
      * "the dot is lit and no session finished" is answerable from `/vrmpet3d/state` alone instead of by guesswork.
@@ -6700,9 +7083,32 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     /** Which pending interaction wins when several sessions are waiting at once. Approval is the rarer. */
     var waitingKind = null;
     var self = this;
+    this.attentionSessions.forEach(function (_kind, id) {
+      var status = statuses.get ? statuses.get(id) : undefined;
+      // Navigating away, a missing report, or losing focus is not an answer to the problem.
+      if (status) {
+        if (status.pendingInteraction == null) self.attentionSessions.delete(id);
+        else self.attentionSessions.set(id, pendingInteractionKind(status.pendingInteraction));
+      }
+    });
     ids.forEach(function (id) {
       if (!self.inScope(id)) return;
       var status = statuses.get ? statuses.get(id) : undefined;
+      var record = self.records.get(id);
+      if (status && status.completionUnread === true && self.mainSession(id) && !self.completionSeen.has(id)
+        && self.running(id) === false && status.pendingInteraction == null) {
+        self.rememberCompletion({ sessionId: id, reason: 'completed', at: self.now() }, false);
+      }
+      var completed = self.completionQueue.has(id) && !self.viewedCompletions.has(id) && self.mainSession(id)
+        && self.running(id) === false && (!status || status.pendingInteraction == null)
+        && !(record && record.lastEndReason && record.lastEndReason !== 'completed');
+      if (!completed) self.completionChecks.delete(id);
+      else {
+        if (!self.completionChecks.has(id)) self.completionChecks.set(id, self.now());
+        if (self.completionQueue.get(id).confirmed || self.now() - self.completionChecks.get(id) >= COMPLETION_SETTLE_MS) {
+          completedSessionIds.push(id);
+        }
+      }
       if (status && status.completionUnread === true) {
         unreadDetail.candidates += 1;
         var entry = (catalog.byId || {})[id];
@@ -6725,14 +7131,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
       var pending = status ? status.pendingInteraction != null : false;
       if (pending) {
-        waitingCount++;
-        var kind = pendingInteractionKind(status.pendingInteraction);
-        // Ranked rather than first-wins: a global-scope pet watching ten sessions must not report
-        // "a question" just because that session happens to come out of the map first when another one
-        // is blocked on a permission prompt.
-        if (waitingKind === null || PENDING_KIND_RANK.indexOf(kind) < PENDING_KIND_RANK.indexOf(waitingKind)) {
-          waitingKind = kind;
-        }
+        self.attentionSessions.set(id, pendingInteractionKind(status.pendingInteraction));
       }
       // One rule for "this is the user's own session", shared with the two completion paths (`mainSession`).
       if (self.mainSession(id) && self.running(id) === true) {
@@ -6743,7 +7142,23 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
     });
 
+    this.attentionSessions.forEach(function (kind, id) {
+      waitingCount++;
+      if (waitingKind === null || PENDING_KIND_RANK.indexOf(kind) < PENDING_KIND_RANK.indexOf(waitingKind)) {
+        waitingKind = kind;
+        waitingSessionId = id;
+      }
+    });
+    completedSessionIds.sort(function (a, b) { return self.completionQueue.get(a).at - self.completionQueue.get(b).at; });
+    completedUnreadCount = completedSessionIds.length;
+    completedSessionId = completedSessionIds[0] || null;
+    var waitingSessionIds = Array.from(this.attentionSessions.keys()).sort(function (a, b) {
+      return PENDING_KIND_RANK.indexOf(self.attentionSessions.get(a)) - PENDING_KIND_RANK.indexOf(self.attentionSessions.get(b));
+    });
     var ready = catalog.phase === 'ready';
+    self.completionChecks.forEach(function (_at, id) {
+      if (!ids.has(id) || !self.inScope(id)) self.completionChecks.delete(id);
+    });
 
     // Availability is "there is a session whose activity this pet could show".
     // In `current` scope that must be proved by the selected session actually
@@ -6756,7 +7171,12 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
 
     var hasAnything = ready || workingCount > 0 || waitingCount > 0 || Boolean(this.notice);
     var available = this.input.connected === true && hasAnything && hasSelectedSession;
-    var notice = available && this.notice ? this.notice : undefined;
+    var queuedNotice;
+    this.completionQueue.forEach(function (entry, id) {
+      if (!queuedNotice && entry.announce && self.mainSession(id) && self.inScope(id) && self.running(id) === false) queuedNotice = entry;
+    });
+    var notice = available ? (this.notice && this.notice.reason === 'error' ? this.notice
+      : (queuedNotice || (this.notice && !this.viewedCompletions.has(this.notice.sessionId) ? this.notice : undefined))) : undefined;
     /**
      * `connected` rides along, because 离线 is decided by the CONNECTION and not by `available`.
      *
@@ -6812,6 +7232,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       pendingKind: waitingCount > 0 ? waitingKind : null,
       workingCount: workingCount,
       waitingCount: waitingCount,
+      waitingSessionId: waitingSessionId,
+      waitingSessionIds: waitingSessionIds,
       /**
        * Sessions whose completion is still UNREAD (see above), and whether there are any.
        *
@@ -6819,6 +7241,10 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
        * surface could say more later without another plumbing round.
        */
       unreadCount: unreadCount,
+      completedUnreadCount: completedUnreadCount,
+      completedSessionId: completedSessionId,
+      completedSessionIds: completedSessionIds,
+      viewedCompletions: Array.from(this.viewedCompletions),
       hasUnread: unreadCount > 0,
       /** The breakdown behind that count — see `unreadDetail` where it is built. */
       unreadDetail: unreadDetail,
@@ -7299,6 +7725,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     STATES: STATES,
     INTERACTION_STATES: INTERACTION_STATES,
     STATUS_STATES: STATUS_STATES,
+    LANGUAGE_SETTINGS: LANGUAGE_SETTINGS,
+    cleanLanguage: cleanLanguage,
+    resolveLanguage: resolveLanguage,
+    browserLanguageHints: browserLanguageHints,
+    textFor: textFor,
+    textOf: textOf,
+    applyI18n: applyI18n,
+    defaultStatusText: defaultStatusText,
     DEFAULT_STATUS_TEXT: DEFAULT_STATUS_TEXT,
     STATUS_TAGS: STATUS_TAGS,
     STATUS_ANIMATIONS: STATUS_ANIMATIONS,