dsh-plugin-vrmpet3d 0.1.1 → 0.1.2

package/lib/core.js

@@ -1179,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);
@@ -1189,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;
   }
 
   /**
@@ -1211,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
    */
@@ -1230,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)
     };
   }
 
@@ -1348,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.
      *
@@ -1465,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 }`.
      *
@@ -2199,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))
@@ -2259,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;
   }
 
@@ -2269,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 : {};
@@ -3552,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) {
@@ -3816,7 +3895,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    *
    * @returns {{state: string, text: string, tag: string, animation: string, seconds: number}|null}
    */
-  function statusFor(preferences, state, enteredAt, now, clock, language) {
+  function statusFor(preferences, state, enteredAt, now, clock, language, completedCount) {
     if (STATUS_STATES.indexOf(state) === -1) return null;
     var entry = statusEntryFor(preferences, state, language);
     if (!entry.text && !entry.tag) return null;
@@ -3873,6 +3952,9 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
         ? durationClauseRemoved(text)
         : 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 {
       state: state,
@@ -4906,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
@@ -4914,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) {
@@ -4930,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);
@@ -5067,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) {
@@ -5083,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;
@@ -5192,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
@@ -5349,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;
@@ -5482,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);
@@ -5495,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) {
@@ -5506,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; });
     }
 
@@ -5518,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',
@@ -5525,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; });
     }
 
@@ -5738,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.
      *
@@ -6020,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];
@@ -6142,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();
       }
@@ -6254,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,
           };
         }
@@ -6279,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.
@@ -6299,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.
@@ -6311,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,
@@ -6327,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.
@@ -6349,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
@@ -6425,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';
@@ -6448,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;
@@ -6476,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
@@ -6487,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.
@@ -6594,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.
      *
@@ -6653,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;
@@ -6676,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)) {
@@ -6696,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;
@@ -6722,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);
@@ -6737,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
@@ -6758,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;
@@ -6839,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;
       }
@@ -6857,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.
      *
@@ -6873,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.
@@ -6888,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];
@@ -6913,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) {
@@ -6931,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
@@ -6944,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`.
      *
@@ -7000,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.
        *
@@ -7007,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,