ocuclaw 1.3.1 → 1.3.2

package/dist/runtime/display-toggle-states.js

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const DEFAULTS = { emoji: false, pace: false };
+const STORE_FILENAME = "ocuclaw-display-toggles.json";
+
+/**
+ * Tracks, per session, the display-feature toggle state at session start
+ * (frozen on first record) and the latest reported state.
+ *
+ * The FROZEN start-state is persisted to stateDir so it survives a relay/plugin
+ * restart — the Channel-1 prompt snapshot is also persisted, so without this the
+ * Channel-2 disable stop-notice would be lost after a restart (a session that
+ * started with a feature ON would re-freeze start=OFF from the first post-restart
+ * send and never notice the disable). The CURRENT state is NOT persisted: it
+ * re-derives from the next send, so persisting it would mean a write per turn.
+ */
+export function createDisplayToggleTracker(opts = {}) {
+  const limit = Number.isFinite(opts.limit) ? opts.limit : 200;
+  const statePath =
+    typeof opts.stateDir === "string" && opts.stateDir.trim()
+      ? path.join(opts.stateDir.trim(), STORE_FILENAME)
+      : null;
+  /** @type {Map<string,{start:{emoji,pace},current:{emoji,pace}}>} */
+  const byKey = new Map();
+
+  function norm(v) {
+    return { emoji: !!(v && v.emoji), pace: !!(v && v.pace) };
+  }
+
+  function load() {
+    if (!statePath) return;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+      if (parsed && parsed.entries && typeof parsed.entries === "object") {
+        for (const [k, v] of Object.entries(parsed.entries)) {
+          if (v && v.start) {
+            const start = norm(v.start);
+            // current re-derives on the next send; seed it from start until then.
+            byKey.set(k, { start, current: { ...start } });
+          }
+        }
+      }
+    } catch (_e) {
+      // Missing/corrupt store is non-fatal: start empty.
+    }
+  }
+
+  function persist() {
+    if (!statePath) return;
+    try {
+      const entries = {};
+      for (const [k, v] of byKey.entries()) entries[k] = { start: v.start };
+      const tmp = `${statePath}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify({ version: 1, entries }), { mode: 0o600 });
+      fs.renameSync(tmp, statePath);
+    } catch (_e) {
+      // Best-effort persistence.
+    }
+  }
+
+  function evictIfNeeded() {
+    while (byKey.size > limit) {
+      const oldest = byKey.keys().next().value;
+      if (oldest === undefined) break;
+      byKey.delete(oldest);
+    }
+  }
+
+  load();
+
+  return {
+    record(sessionKey, states) {
+      const cur = norm(states);
+      const existing = byKey.get(sessionKey);
+      if (!existing) {
+        byKey.set(sessionKey, { start: cur, current: cur });
+        evictIfNeeded();
+        persist(); // a new frozen start-state was recorded
+        return;
+      }
+      existing.current = cur; // start stays frozen; no persist (start unchanged)
+    },
+    getStart(sessionKey) {
+      const e = byKey.get(sessionKey);
+      return e ? { ...e.start } : { ...DEFAULTS };
+    },
+    getCurrent(sessionKey) {
+      const e = byKey.get(sessionKey);
+      return e ? { ...e.current } : { ...DEFAULTS };
+    },
+    clear(sessionKey) {
+      if (byKey.delete(sessionKey)) persist();
+    },
+  };
+}
+
+export default createDisplayToggleTracker;

package/dist/runtime/register-session-title-distiller.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs/promises";
+import { createSessionTitleDistiller } from "./session-title-distiller.js";
+import { stripAgentSessionPrefix } from "./session-title-distiller-helpers.js";
+
+function genRunId() {
+  const c = globalThis && globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return `ocuclaw-title-${c.randomUUID()}`;
+  return `ocuclaw-title-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+export function registerSessionTitleDistiller(api, service) {
+  if (!api || typeof api.on !== "function") return () => {};
+  // The budget lives in sessionService (so a logical reset clears it with the
+  // title record + toggle state). Resolve it lazily per call: at registration
+  // the live relay may not exist yet, and a sibling context resolves the shared
+  // relay's budget.
+  const budget = {
+    canRun: (k) => {
+      const b = service.getDistillerBudget();
+      return b ? b.canRun(k) : true;
+    },
+    recordTurn: (k) => {
+      const b = service.getDistillerBudget();
+      if (b) b.recordTurn(k);
+    },
+    recordOutcome: (k, o) => {
+      const b = service.getDistillerBudget();
+      if (b) b.recordOutcome(k, o);
+    },
+  };
+  const distiller = createSessionTitleDistiller({
+    // Lazy getter: the real state dir only arrives at service.start(), after
+    // this distiller is constructed during registration.
+    getStateDir: () => (service.getStateDir ? service.getStateDir() : undefined),
+    nowMs: () => Date.now(),
+    genId: genRunId,
+    emitDebug: (...a) => (service.emitDebug ? service.emitDebug(...a) : undefined),
+    getSessionTitleModel: () => service.getRuntimeConfig().sessionTitleModel || "",
+    conversationState: { getRawMessages: () => service.getRawMessages() },
+    sessionService: {
+      getSessionTitleRecord: (k) => service.getSessionTitleRecord(k),
+      isNeuralSessionNamesEnabled: (k) => service.isNeuralSessionNamesEnabled(k),
+      isSessionUserLocked: (k) => service.isSessionUserLocked(k),
+      hasRecordedUserMessage: (k) => service.hasRecordedUserMessage(k),
+      setSessionTitle: (k, t, o) => service.setSessionTitle(k, t, o),
+    },
+    isEvenAiSessionKey: (k) => service.isEvenAiSessionKey(k),
+    cleanupDistillerSession: (k) =>
+      typeof service.deleteDistillerSession === "function"
+        ? service.deleteDistillerSession(k)
+        : Promise.resolve(null),
+    subagentRuntime: (() => {
+      const sa = api && api.runtime && api.runtime.subagent;
+      if (
+        !sa ||
+        typeof sa.run !== "function" ||
+        typeof sa.waitForRun !== "function" ||
+        typeof sa.getSessionMessages !== "function" ||
+        typeof sa.deleteSession !== "function"
+      ) {
+        return null;
+      }
+      return {
+        run: (p) => sa.run(p),
+        waitForRun: (p) => sa.waitForRun(p),
+        getSessionMessages: (p) => sa.getSessionMessages(p),
+        deleteSession: (p) => sa.deleteSession(p),
+      };
+    })(),
+    gatewayBridge: {
+      request: (m, p, o) => service.gatewayRequest(m, p, o),
+      on: (evt, cb) => service.onGatewayEvent(evt, cb),
+    },
+    fs,
+    budget,
+  });
+
+  return api.on("agent_end", (event, ctx) => {
+    // 2026.6.x delivers the canonical `agent:<id>:<key>` form; relay state is
+    // keyed by the bare relay key — normalize at the boundary.
+    const rawSessionKey = ctx && typeof ctx.sessionKey === "string" ? ctx.sessionKey : null;
+    const sessionKey = stripAgentSessionPrefix(rawSessionKey);
+    if (!sessionKey) return;
+    // Capture the completed run's messages NOW, before the fire-and-forget run
+    // defers: agent_end carries the run's final messages (the authoritative
+    // source for THIS session). Fall back to a synchronous snapshot of the live
+    // conversation state. Either way the messages are pinned here so a later
+    // session switch / clear can't make the distiller title from another
+    // session's transcript.
+    const eventMessages = event && Array.isArray(event.messages) ? event.messages : null;
+    const messages =
+      eventMessages && eventMessages.length
+        ? eventMessages
+        : service.getRawMessages();
+    // Fire-and-forget; never block run teardown.
+    Promise.resolve(distiller.maybeRun(sessionKey, { messages })).catch(() => {});
+  });
+}
+
+export default registerSessionTitleDistiller;

package/dist/runtime/relay-core.js

@@ -9,6 +9,8 @@ import { composeReadabilitySystemPrompt } from "../domain/readability-system-pro
 import { composeNeuralEmojiReactorSystemPrompt } from "../domain/neural-emoji-reactor-system-prompt.js";
 import { composeNeuralPaceModulatorSystemPrompt } from "../domain/neural-pace-modulator-system-prompt.js";
 import { composeGlassesUiNudgeSystemPrompt } from "../domain/glasses-ui-system-prompt.js";
+import { composeGlassesDisplaySystemPrompt } from "../domain/glasses-display-system-prompt.js";
+import { createStablePromptSnapshotStore } from "./stable-prompt-snapshot.js";
 import { createActivityStatusAdapter } from "../domain/activity-status-adapter.js";
 import { createEvenAiEndpoint } from "../even-ai/even-ai-endpoint.js";
 import { createEvenAiRouter } from "../even-ai/even-ai-router.js";
@@ -359,7 +361,9 @@ function createRelay(opts) {
   /** Relay-local deterministic simulate-stream run sequence counter. */
   let simulateStreamRunSeq = 0;
   /** Active timers for relay-local deterministic simulate-stream runs. */
-  const simulateStreamTimers = new Set();
+  // timer -> sessionKey, so new-chat//reset/new-session can cancel ONLY the
+  // affected session's pending injections (re-land of a8a29032, session-scoped).
+  const simulateStreamTimers = new Map();
 
   // --- Structured debug state ---
 
@@ -550,7 +554,7 @@ function createRelay(opts) {
     );
   }
 
-  function scheduleSimulateStreamTimer(delayMs, callback) {
+  function scheduleSimulateStreamTimer(delayMs, callback, sessionKey) {
     const timer = setTimeout(() => {
       simulateStreamTimers.delete(timer);
       try {
@@ -559,12 +563,29 @@ function createRelay(opts) {
         logger.error(`[relay] simulate-stream timer failed: ${err.message}`);
       }
     }, delayMs);
-    simulateStreamTimers.add(timer);
+    simulateStreamTimers.set(timer, typeof sessionKey === "string" ? sessionKey : null);
     return timer;
   }
 
+  function clearSimulateStreamTimersForSession(sessionKey) {
+    let cleared = 0;
+    for (const [timer, timerSessionKey] of simulateStreamTimers) {
+      if (timerSessionKey === sessionKey) {
+        clearTimeout(timer);
+        simulateStreamTimers.delete(timer);
+        cleared += 1;
+      }
+    }
+    if (cleared > 0) {
+      logger.info(
+        `[relay] cancelled ${cleared} pending simulate-stream timer(s) for session ${sessionKey}`,
+      );
+    }
+    return cleared;
+  }
+
   function clearSimulateStreamTimers() {
-    for (const timer of simulateStreamTimers) {
+    for (const timer of simulateStreamTimers.keys()) {
       clearTimeout(timer);
     }
     simulateStreamTimers.clear();
@@ -923,37 +944,67 @@ function createRelay(opts) {
       systemPrompt: opts.ocuClawSystemPrompt,
     },
   });
-
-  function currentOcuClawSendOptions(perTurnSignals) {
-    const signals = perTurnSignals || {};
+  const stablePromptSnapshots = createStablePromptSnapshotStore({
+    stateDir: opts.stateDir,
+    emitDebug,
+  });
+  // Hourly TTL sweep for stale stable-prompt snapshots; started in start(),
+  // cleared in stop(). Declared here so both can see it.
+  let stablePromptSweepTimer = null;
+
+  // Channel 1: the per-session-immutable extraSystemPrompt. Computed once from
+  // the feature set AT SESSION START and then served byte-identical for the
+  // session's lifetime (see stable-prompt-snapshot). Mid-session toggles are
+  // bridged by the Channel-2 hook composer, NOT here. The glasses-UI pointer is
+  // always present (its disconnected gate moved to Channel 2); the emoji/pace
+  // blocks are included only when active at session start.
+  function computeStableChannelOne(startSignals) {
     const baseReadability = composeReadabilitySystemPrompt(
       ocuClawSettingsStore.getSnapshot().systemPrompt,
     );
-    const validState = (raw) =>
-      raw === "active" || raw === "recently-disabled" || raw === "inactive"
-        ? raw
-        : "inactive";
-    const reactorState = validState(signals.neuralEmojiReactorState);
-    const paceState = validState(signals.neuralPaceModulatorState);
-    const reactor = composeNeuralEmojiReactorSystemPrompt({ state: reactorState });
-    const pace = composeNeuralPaceModulatorSystemPrompt({ state: paceState });
-    // Only include the glasses-UI nudge when a downstream app client is
-    // connected. Keeps the prompt clean when the agent has nowhere to render
-    // the tool's output, and keeps existing prompt-assembly tests stable
-    // (they exercise the prompt without spinning up an app client).
-    const hasAppClient =
-      server &&
-      typeof server.getConnectedAppCount === "function" &&
-      server.getConnectedAppCount() > 0;
-    const glassesUiNudge = hasAppClient ? composeGlassesUiNudgeSystemPrompt() : "";
+    const display = composeGlassesDisplaySystemPrompt({
+      emoji: startSignals.emoji,
+      pace: startSignals.pace,
+    });
+    const glassesPointer = composeGlassesUiNudgeSystemPrompt();
     const parts = [];
     if (baseReadability) parts.push(baseReadability);
-    if (reactor) parts.push(reactor);
-    if (pace) parts.push(pace);
-    if (glassesUiNudge) parts.push(glassesUiNudge);
-    return {
-      extraSystemPrompt: parts.join("\n\n"),
-    };
+    if (display) parts.push(display);
+    if (glassesPointer) parts.push(glassesPointer);
+    return parts.join("\n\n");
+  }
+
+  function stableSendOptions(resolvedSessionKey, sessionId, perTurnSignals) {
+    const signals = perTurnSignals || {};
+    // "enabled at start" = the client's reported state on the FIRST send of the
+    // session. The 3-state client signal maps to a boolean: only "active" counts.
+    const startEmoji = signals.neuralEmojiReactorState === "active";
+    const startPace = signals.neuralPaceModulatorState === "active";
+    const extraSystemPrompt = stablePromptSnapshots.getOrCreate(
+      resolvedSessionKey,
+      sessionId,
+      () => computeStableChannelOne({ emoji: startEmoji, pace: startPace }),
+    );
+    // Churn guard: if recomputing TODAY would differ from the served snapshot,
+    // something is mutating Channel 1 mid-session (e.g. a toggle flipped the
+    // start-state signals) — the case that used to reset the CLI session.
+    // Surface it loudly; the served prompt stays the frozen snapshot.
+    if (
+      stablePromptSnapshots.wouldChurn(
+        resolvedSessionKey,
+        sessionId,
+        computeStableChannelOne({ emoji: startEmoji, pace: startPace }),
+      )
+    ) {
+      emitDebug(
+        "relay.session",
+        "stable_prompt_churn_detected",
+        "warn",
+        { sessionKey: resolvedSessionKey },
+        () => ({ sessionId: sessionId || null }),
+      );
+    }
+    return { extraSystemPrompt };
   }
 
   function buildOcuClawSendDiagnostic(params = {}) {
@@ -1465,6 +1516,10 @@ function createRelay(opts) {
         resolvedSessionKey,
         clientDisplaySignals.neuralSessionNamesEnabled !== false,
       );
+      sessionService.recordDisplayToggleStates(resolvedSessionKey, {
+        emoji: clientDisplaySignals.neuralEmojiReactorState === "active",
+        pace: clientDisplaySignals.neuralPaceModulatorState === "active",
+      });
     }
     const hasAttachment = !!attachment;
     const sendStartedAt = Date.now();
@@ -1494,7 +1549,16 @@ function createRelay(opts) {
         resolvedSessionKey,
         attachment,
         {
-          ...currentOcuClawSendOptions(clientDisplaySignals),
+          ...stableSendOptions(
+            resolvedSessionKey,
+            // No synchronous OpenClaw sessionId is available at send time
+            // (resolveSessionCanonicalKey is async). Use the sessionKey as the
+            // snapshot's id; the sessionId-mismatch guard is therefore a no-op,
+            // and new-session safety rests on logical-session-end eviction
+            // (onNewSession / onNewChat / onDeleteSessions evict the snapshot).
+            resolvedSessionKey,
+            clientDisplaySignals,
+          ),
           diagnostic: buildOcuClawSendDiagnostic({
             ...params,
             sessionKey: resolvedSessionKey,
@@ -1768,6 +1832,14 @@ function createRelay(opts) {
       return upstreamRuntime.compactActiveSession(sessionKey);
     },
     onDeleteSessions(sessionKeys, kind, switchBeforeDelete) {
+      if (Array.isArray(sessionKeys)) {
+        for (const key of sessionKeys) {
+          if (typeof key === "string" && key.trim()) {
+            stablePromptSnapshots.evict(key);
+            sessionService.clearDisplayToggleStates(key);
+          }
+        }
+      }
       const action = switchBeforeDelete
         ? sessionService.switchAndDeleteSessions(kind, sessionKeys)
         : sessionService.deleteSessions(kind, sessionKeys);
@@ -1904,7 +1976,7 @@ function createRelay(opts) {
               totalChars: text.length,
             }),
           );
-        });
+        }, sessionKey);
       }
 
       const completeDelayMs = startDelayMs + (chunkCount * chunkIntervalMs) + thinkingTailMs;
@@ -1935,7 +2007,7 @@ function createRelay(opts) {
             completeDelayMs,
           }),
         );
-      });
+      }, sessionKey);
 
       return Promise.resolve({
         status: "accepted",
@@ -1962,7 +2034,18 @@ function createRelay(opts) {
       }
       sessionService.invalidateSessionsCache();
       resetActivityStatusAdapter();
+      // Cancel THIS session's pending simulate-stream timers BEFORE clearing —
+      // a deferred addMessage firing after the clear repopulates the fresh chat
+      // (the 2026-05-15 canary-pollution mechanism).
+      clearSimulateStreamTimersForSession(sessionService.ensureSessionKey());
       conversationState.clear();
+      // Logical session end: this key is REUSED for a fresh conversation, so the
+      // Channel-1 snapshot must be dropped or the next send serves a stale prompt,
+      // and ALL other per-session state keyed to it (title + upstream name,
+      // toggles, distiller budget, first-user marker) must be cleared too.
+      const newChatSessionKey = sessionService.ensureSessionKey();
+      stablePromptSnapshots.evict(newChatSessionKey);
+      sessionService.clearLogicalSessionState(newChatSessionKey);
       conversationState.setAgentName(
         (upstreamRuntime ? upstreamRuntime.getAgentName() : null) || "Agent",
       );
@@ -2000,7 +2083,20 @@ function createRelay(opts) {
     },
 
     async onNewSession() {
+      // Cancel pending simulate-stream timers scheduled under the outgoing key
+      // BEFORE the new key is minted — a deferred addMessage firing after the
+      // switch would repopulate the fresh session's shared conversation view.
+      clearSimulateStreamTimersForSession(sessionService.ensureSessionKey());
       const result = await sessionService.newSession();
+      // newSession() mints a FRESH key; defensively clear only the NEW key (it
+      // has no snapshot yet). Do NOT touch the previous key: that session stays
+      // resumable via onSwitchSession, and dropping its frozen snapshot would
+      // recompute — and churn — Channel 1 if the user switches back to it. The
+      // previous session's snapshot is released by delete or the TTL sweep.
+      if (result && typeof result.sessionKey === "string" && result.sessionKey.trim()) {
+        stablePromptSnapshots.evict(result.sessionKey);
+        sessionService.clearDisplayToggleStates(result.sessionKey);
+      }
       clearCurrentSessionModelConfigSnapshot("new_session");
       if (upstreamRuntime && typeof upstreamRuntime.clearTyping === "function") {
         upstreamRuntime.clearTyping("new_session");
@@ -2110,6 +2206,7 @@ function createRelay(opts) {
       if (command === "/reset") {
         sessionService.invalidateSessionsCache();
         resetActivityStatusAdapter();
+        clearSimulateStreamTimersForSession(sessionService.ensureSessionKey());
         conversationState.clear();
         if (upstreamRuntime && typeof upstreamRuntime.clearTyping === "function") {
           upstreamRuntime.clearTyping("slash_reset");
@@ -2119,6 +2216,19 @@ function createRelay(opts) {
         );
         broadcastPages();
       }
+      // A user-typed /new or /reset is a logical session reset on the CURRENT
+      // key (distinct from an automatic CLI session reset, which keeps the same
+      // logical session and must survive). Drop the frozen Channel-1 snapshot so
+      // the next real message recomputes it for the fresh conversation; otherwise
+      // the old conversation's prompt + display start-state bleed into the new one.
+      if (command === "/new" || command === "/reset") {
+        const resetKey = sessionService.ensureSessionKey();
+        stablePromptSnapshots.evict(resetKey);
+        // Clear ALL per-session state keyed to the reused key (title + upstream
+        // name, toggles, distiller budget, first-user marker) so nothing from the
+        // old conversation bleeds into the fresh one.
+        sessionService.clearLogicalSessionState(resetKey);
+      }
       if (upstreamRuntime && upstreamRuntime.isConnected()) {
         // Bare /reset no longer elicits an agent turn on OpenClaw 2026.6.x
         // (fast-reset). Append the greeting prompt so Reset gets the same
@@ -3013,6 +3123,16 @@ function createRelay(opts) {
      * The downstream server is already listening from construction.
     */
     start() {
+      // Bounded cleanup of stale stable-prompt snapshots (14-day TTL).
+      if (!stablePromptSweepTimer) {
+        stablePromptSweepTimer = setInterval(
+          () => stablePromptSnapshots.sweep(),
+          60 * 60 * 1000, // hourly
+        );
+        if (typeof stablePromptSweepTimer.unref === "function") {
+          stablePromptSweepTimer.unref();
+        }
+      }
       const startGateway = () => Promise.resolve(gatewayBridge.start()).then(() => {
         prefetchSonioxModels("relay_start").catch((err) => {
           logger.warn(`[relay] Soniox models prefetch failed: ${err.message}`);
@@ -3034,6 +3154,10 @@ function createRelay(opts) {
      */
     stop() {
       clearSimulateStreamTimers();
+      if (stablePromptSweepTimer) {
+        clearInterval(stablePromptSweepTimer);
+        stablePromptSweepTimer = null;
+      }
       if (evenAiEndpoint) {
         evenAiEndpoint.close();
       }
@@ -3113,6 +3237,49 @@ function createRelay(opts) {
       return sessionService.isSessionUserLocked(sessionKey);
     },
 
+    getDisplayStartStates(sessionKey) {
+      return sessionService.getDisplayStartStates(sessionKey);
+    },
+
+    getDisplayCurrentStates(sessionKey) {
+      return sessionService.getDisplayCurrentStates(sessionKey);
+    },
+
+    // Accessors used by the session-title distiller sidecar.
+    getSessionTitleRecord(sessionKey) {
+      return sessionService.getSessionTitleRecord(sessionKey);
+    },
+    isEvenAiSessionKey(sessionKey) {
+      return sessionService.isEvenAiSessionKey(sessionKey);
+    },
+    getRawMessages() {
+      return conversationState.getRawMessages();
+    },
+    getDistillerBudget() {
+      return sessionService.getDistillerBudget();
+    },
+    // Canonical-key cleanup for the distiller's throwaway upstream session.
+    // The native subagent deleteSession passes the bare key straight to
+    // sessions.delete, which the 2026.6.x gateway indexes under the canonical
+    // agent:<id>: form — the bare-key delete silently no-ops and the
+    // excerpt-bearing transcript survives. deleteSessions() resolves the
+    // canonical key via sessions.resolve first.
+    deleteDistillerSession(sessionKey) {
+      return sessionService.deleteSessions("ocuclaw", [sessionKey]);
+    },
+    getStateDir() {
+      return opts.stateDir;
+    },
+    emitDebug(...args) {
+      return emitDebug(...args);
+    },
+    gatewayRequest(method, params, requestOpts) {
+      return gatewayBridge.request(method, params, requestOpts);
+    },
+    onGatewayEvent(eventName, listener) {
+      return gatewayBridge.on(eventName, listener);
+    },
+
     peekSessionKey() {
       return sessionService.peekSessionKey();
     },
@@ -3147,6 +3314,15 @@ function createRelay(opts) {
       return dispatchOcuClawUserSend(params || {});
     },
 
+    /**
+     * Test-only: run the logical-reset state clear (the same call the /new,
+     * /reset, and new-chat paths make) so integration tests can verify all
+     * per-session state is dropped for a reused session key.
+     */
+    _clearLogicalSessionState(sessionKey) {
+      sessionService.clearLogicalSessionState(sessionKey);
+    },
+
     sendGlassesUiRender(params) {
       sendGlassesUiRender(params);
     },