ocuclaw 1.3.2 → 1.3.4

package/dist/tools/glasses-ui-voicemail.js

@@ -0,0 +1,242 @@
+import { sanitizeWakeToken } from "./glasses-ui-wake.js";
+import { normalizeGlassesSessionKey } from "./glasses-ui-surfaces.js";
+
+export const DEFAULT_VOICEMAIL_TTL_MS = 30 * 60_000;
+export const VOICEMAIL_MAX_ENTRIES_PER_INJECTION = 8;
+
+export const VOICEMAIL_PENDING_CAP_PER_SESSION = 32;
+const DELIVERED_KEY_CAP = 256;
+
+const RESULT_ENUM = new Set(["selected", "back"]);
+
+const REAP_REASON_ENUM = new Set(["drain_session", "drain_all", "exit", "pop_back"]);
+
+function coerceInt(value) {
+  return Number.isFinite(value) ? Math.floor(value) : null;
+}
+
+function sanitizeResult(value) {
+  return RESULT_ENUM.has(value) ? value : "event";
+}
+
+const IDEMPOTENCY_KEY_PATTERN = /^[a-z0-9:._-]{1,80}$/i;
+function sanitizeIdempotencyKey(value) {
+  const raw = String(value == null ? "" : value);
+  return IDEMPOTENCY_KEY_PATTERN.test(raw) ? raw : "invalid";
+}
+
+export function createGlassesVoicemail(deps = {}) {
+  const now = typeof deps.now === "function" ? deps.now : Date.now;
+  const ttlMs = Number.isFinite(deps.ttlMs) ? deps.ttlMs : DEFAULT_VOICEMAIL_TTL_MS;
+  const maxEntries = Number.isFinite(deps.maxEntriesPerInjection)
+    ? deps.maxEntriesPerInjection
+    : VOICEMAIL_MAX_ENTRIES_PER_INJECTION;
+  const drainWakeOutbox =
+    typeof deps.drainWakeOutbox === "function" ? deps.drainWakeOutbox : () => [];
+  const drainDeadLetter =
+    typeof deps.drainDeadLetter === "function" ? deps.drainDeadLetter : () => [];
+  const emitLifecycle =
+    typeof deps.emitLifecycle === "function" ? deps.emitLifecycle : () => {};
+
+  const pendingBySession = new Map();
+
+  const deliveredKeys = new Set();
+
+  function rememberDelivered(key) {
+    deliveredKeys.add(key);
+    if (deliveredKeys.size > DELIVERED_KEY_CAP) {
+      const oldest = deliveredKeys.values().next().value;
+      deliveredKeys.delete(oldest);
+    }
+  }
+
+  function dedupeKeyOf(entry) {
+    return `${entry.surfaceUuid}:${entry.eventId === null ? 0 : entry.eventId}`;
+  }
+
+  function ingest(entries, nowMs) {
+    const bySession = new Map();
+    for (const entry of entries) {
+      if (!entry.sessionKey) continue;
+      let batch = bySession.get(entry.sessionKey);
+      if (!batch) { batch = []; bySession.set(entry.sessionKey, batch); }
+      batch.push(entry);
+    }
+    for (const [sessionKey, batch] of bySession) {
+      let expired = 0;
+      const fresh = [];
+      for (const entry of batch) {
+        const basisMs = Number.isFinite(entry.owedSinceMs) ? entry.owedSinceMs : nowMs;
+        if (nowMs - basisMs > ttlMs) { expired += 1; continue; }
+        fresh.push(entry);
+      }
+      if (expired > 0) {
+        emitLifecycle("voicemail_expired", "warn", { sessionKey, dropped: expired, ttlMs });
+      }
+      if (fresh.length === 0) continue;
+      const list = pendingBySession.get(sessionKey) || [];
+      list.push(...fresh);
+      if (list.length > VOICEMAIL_PENDING_CAP_PER_SESSION) {
+        const evicted = list.splice(0, list.length - VOICEMAIL_PENDING_CAP_PER_SESSION);
+        emitLifecycle("voicemail_evicted", "warn", { sessionKey, evicted: evicted.length });
+      }
+      pendingBySession.set(sessionKey, list);
+    }
+  }
+
+  function fromOutbox(record) {
+    const surfaceUuid = sanitizeWakeToken(record && record.surfaceUuid);
+    const eventId = coerceInt(record && record.eventId);
+    return {
+      sessionKey: normalizeGlassesSessionKey(record && record.sessionKey) || null,
+      surfaceUuid,
+      eventId,
+      result: sanitizeResult(record && record.result),
+      itemIndex: coerceInt(record && record.itemIndex),
+      queuedAtMs: coerceInt(record && record.queuedAtMs),
+      owedSinceMs: coerceInt(record && record.failedAtMs) ?? coerceInt(record && record.queuedAtMs),
+      idempotencyKey: sanitizeIdempotencyKey(record && record.idempotencyKey),
+      via: record && record.error === "no_dispatch_lane" ? "wake_unavailable" : "wake_failed",
+      staleAfterMs: null,
+      surfaceLive: true,
+    };
+  }
+
+  function fromDeadLetter(sessionKey, record) {
+    const surfaceUuid = sanitizeWakeToken(record && record.surfaceUuid);
+    const reason =
+      record && REAP_REASON_ENUM.has(record.reason) ? `reaped:${record.reason}` : "reaped";
+    const staleAfterMs = record && Number.isFinite(record.staleAfterMs) ? record.staleAfterMs : null;
+    const events = record && Array.isArray(record.events) ? record.events : [];
+    return events.map((ev) => {
+      const eventId = coerceInt(ev && ev.eventId);
+      return {
+        sessionKey,
+        surfaceUuid,
+        eventId,
+        result: sanitizeResult(ev && ev.outcome && ev.outcome.result),
+        itemIndex: coerceInt(ev && ev.outcome && ev.outcome.selected_index),
+        queuedAtMs: coerceInt(ev && ev.queuedAtMs),
+        owedSinceMs: coerceInt(ev && ev.queuedAtMs) ?? coerceInt(record && record.reapedAtMs),
+        idempotencyKey: `glasses-voicemail:${surfaceUuid}:${eventId === null ? 0 : eventId}`,
+        via: reason,
+        staleAfterMs,
+        surfaceLive: false,
+      };
+    });
+  }
+
+  function formatEntry(entry, nowMs) {
+    const ageMs = Number.isFinite(entry.queuedAtMs) ? Math.max(0, nowMs - entry.queuedAtMs) : null;
+    const stale =
+      Number.isFinite(entry.staleAfterMs) && ageMs !== null && ageMs > entry.staleAfterMs;
+    const parts = [
+      `- surfaceUuid=${entry.surfaceUuid}`,
+      `eventId=${entry.eventId}`,
+      `result=${entry.result}`,
+      `itemIndex=${entry.itemIndex}`,
+      `queuedAtMs=${entry.queuedAtMs}`,
+      `ageMs=${ageMs}`,
+      `via=${entry.via}`,
+      `idempotencyKey=${entry.idempotencyKey}`,
+    ];
+    if (stale) parts.push("stale=true");
+    parts.push(
+      entry.surfaceLive
+        ? '(surface may still be live: re-render it with update:"patch" to collect)'
+        : "(surface no longer live: treat the refs as the wearer's parked answer to that surface; re-confirm before acting if stale)",
+    );
+    return parts.join(" ");
+  }
+
+  function sweepExpired(nowMs) {
+    for (const [key, list] of pendingBySession) {
+      const fresh = list.filter((entry) => {
+        const basisMs = Number.isFinite(entry.owedSinceMs) ? entry.owedSinceMs : nowMs;
+        return nowMs - basisMs <= ttlMs;
+      });
+      const dropped = list.length - fresh.length;
+      if (dropped > 0) {
+        emitLifecycle("voicemail_expired", "warn", { sessionKey: key, dropped, ttlMs });
+      }
+      if (fresh.length === 0) {
+        pendingBySession.delete(key);
+      } else if (dropped > 0) {
+        pendingBySession.set(key, fresh);
+      }
+    }
+  }
+
+  function pendingSessionCount() {
+    return pendingBySession.size;
+  }
+
+  function buildInjection(rawSessionKey) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
+    if (typeof sessionKey !== "string" || !sessionKey) return null;
+    const nowMs = now();
+    sweepExpired(nowMs);
+
+    ingest(
+      [
+        ...drainWakeOutbox().map((record) => fromOutbox(record)),
+        ...(drainDeadLetter(sessionKey) || []).flatMap((r) => fromDeadLetter(sessionKey, r)),
+      ],
+      nowMs,
+    );
+
+    const pending = pendingBySession.get(sessionKey);
+    if (!pending || pending.length === 0) {
+      pendingBySession.delete(sessionKey);
+      return null;
+    }
+    pendingBySession.delete(sessionKey);
+
+    const byEvent = new Map();
+    for (const entry of pending) {
+      const key = dedupeKeyOf(entry);
+      const existing = byEvent.get(key);
+      if (!existing || (existing.surfaceLive && !entry.surfaceLive)) {
+        byEvent.set(key, entry);
+      }
+    }
+
+    const deliverable = [];
+    let dropped = 0;
+    for (const entry of byEvent.values()) {
+      const basisMs = Number.isFinite(entry.owedSinceMs) ? entry.owedSinceMs : nowMs;
+      if (nowMs - basisMs > ttlMs) { dropped += 1; continue; }
+      const key = dedupeKeyOf(entry);
+      if (deliveredKeys.has(key)) continue;
+      rememberDelivered(key);
+      deliverable.push(entry);
+    }
+    if (dropped > 0) {
+
+      emitLifecycle("voicemail_expired", "warn", { sessionKey, dropped, ttlMs });
+    }
+    if (deliverable.length === 0) return null;
+
+    const shown = deliverable.slice(-maxEntries);
+    const overflow = deliverable.length - shown.length;
+    const lines = [
+      "[ocuclaw glasses-ui voicemail] Plugin-generated notification - NOT the wearer speaking.",
+      "Parked glasses events could not be delivered by a wake turn while you were away:",
+      ...shown.map((entry) => formatEntry(entry, nowMs)),
+    ];
+    if (overflow > 0) lines.push(`(+${overflow} older parked events omitted)`);
+    lines.push("Tapped content is never included here by design.");
+    const fragment = lines.join("\n");
+    emitLifecycle("voicemail_injected", "debug", {
+      sessionKey,
+      entries: shown.length,
+      overflow,
+      chars: fragment.length,
+    });
+    return fragment;
+  }
+
+  return { buildInjection, pendingSessionCount };
+}
+
+export default { createGlassesVoicemail, DEFAULT_VOICEMAIL_TTL_MS, VOICEMAIL_MAX_ENTRIES_PER_INJECTION };

package/dist/tools/glasses-ui-wake.js

@@ -0,0 +1,195 @@
+export const GLASSES_WAKE_ENABLED_ORIGINS = ["gesture"];
+
+export const DEFAULT_WAKE_COOLDOWN_MS = 5_000;
+
+export const WAKE_OUTBOX_CAP = 64;
+
+export const DEFAULT_AGENT_TURN_BUSY_DECAY_MS = 180_000;
+
+const SURFACE_UUID_PATTERN = /^su-[a-z0-9]{4,24}$/i;
+const WAKE_RESULT_ENUM = new Set(["selected", "back"]);
+
+export function sanitizeWakeToken(value) {
+  const raw = String(value == null ? "" : value);
+  return SURFACE_UUID_PATTERN.test(raw) ? raw : "invalid";
+}
+
+function sanitizeWakeResult(value) {
+  return WAKE_RESULT_ENUM.has(value) ? value : "event";
+}
+
+function coerceInt(value) {
+  return Number.isFinite(value) ? Math.floor(value) : null;
+}
+
+export function buildWakeMessage(ref) {
+  const surfaceUuid = sanitizeWakeToken(ref && ref.surfaceUuid);
+  const result = sanitizeWakeResult(ref && ref.result);
+  const eventId = coerceInt(ref && ref.eventId);
+  const itemIndex = coerceInt(ref && ref.itemIndex);
+  const queuedAtMs = coerceInt(ref && ref.queuedAtMs);
+  return [
+    "[ocuclaw glasses-ui wake] Plugin-generated notification - NOT the wearer speaking.",
+    `The wearer tapped a parked glasses surface (origin=gesture). refs: surfaceUuid=${surfaceUuid}`,
+    `eventId=${eventId} result=${result} itemIndex=${itemIndex} queuedAtMs=${queuedAtMs}.`,
+    "Tapped content is not included here by design: re-render that surface",
+    "(update:\"patch\") to collect the parked event(s), then respond as appropriate.",
+  ].join(" ");
+}
+
+export function createAgentTurnTracker(deps = {}) {
+  const now = typeof deps.now === "function" ? deps.now : Date.now;
+  const busyDecayMs = Number.isFinite(deps.busyDecayMs)
+    ? deps.busyDecayMs
+    : DEFAULT_AGENT_TURN_BUSY_DECAY_MS;
+  const lastSeenBySession = new Map();
+
+  function normalizeKey(sessionKey) {
+    return sessionKey.replace(/^agent:[^:]+:/, "");
+  }
+
+  function markBusy(sessionKey) {
+    if (typeof sessionKey !== "string" || !sessionKey) return;
+    lastSeenBySession.set(normalizeKey(sessionKey), now());
+  }
+
+  function onActivity(sessionKey, phase) {
+    if (typeof sessionKey !== "string" || !sessionKey) return;
+    if (phase === "end") {
+      lastSeenBySession.delete(normalizeKey(sessionKey));
+      return;
+    }
+    lastSeenBySession.set(normalizeKey(sessionKey), now());
+  }
+
+  function isBusy(sessionKey) {
+    if (typeof sessionKey !== "string" || !sessionKey) return false;
+    const key = normalizeKey(sessionKey);
+    const lastSeen = lastSeenBySession.get(key);
+    if (!Number.isFinite(lastSeen)) return false;
+    if (now() - lastSeen >= busyDecayMs) {
+      lastSeenBySession.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  return { markBusy, onActivity, isBusy };
+}
+
+export function createGlassesWakeController(deps = {}) {
+  const dispatchWake = typeof deps.dispatchWake === "function" ? deps.dispatchWake : null;
+  const isAgentTurnBusy =
+    typeof deps.isAgentTurnBusy === "function" ? deps.isAgentTurnBusy : () => false;
+  const emitLifecycle =
+    typeof deps.emitLifecycle === "function" ? deps.emitLifecycle : () => {};
+  const now = typeof deps.now === "function" ? deps.now : Date.now;
+  const wakeCooldownMs = Number.isFinite(deps.wakeCooldownMs)
+    ? deps.wakeCooldownMs
+    : DEFAULT_WAKE_COOLDOWN_MS;
+
+  const inFlightBySession = new Map();
+  const lastWakeAtBySession = new Map();
+  const outbox = [];
+
+  function pushOutbox(entry) {
+    outbox.push(entry);
+    if (outbox.length > WAKE_OUTBOX_CAP) {
+      const evicted = outbox.splice(0, outbox.length - WAKE_OUTBOX_CAP);
+      emitLifecycle("wake_outbox_evicted", "warn", { evicted: evicted.length });
+    }
+  }
+
+  function refsOnly(ref) {
+    return {
+      sessionKey: typeof ref.sessionKey === "string" ? ref.sessionKey : null,
+      surfaceUuid: sanitizeWakeToken(ref.surfaceUuid),
+      eventId: coerceInt(ref.eventId),
+      result: sanitizeWakeResult(ref.result),
+      itemIndex: coerceInt(ref.itemIndex),
+
+      origin: typeof ref.origin === "string" ? ref.origin : "gesture",
+      queuedAtMs: coerceInt(ref.queuedAtMs),
+    };
+  }
+
+  function suppress(reason, refs) {
+    emitLifecycle("wake_suppressed", "debug", { reason, ...refs });
+    return { dispatched: false, reason };
+  }
+
+  function onParkedGesture(ref) {
+    const refs = refsOnly(ref || {});
+    if (!dispatchWake) {
+
+      if (GLASSES_WAKE_ENABLED_ORIGINS.includes(refs.origin) && refs.sessionKey) {
+        if (refs.queuedAtMs === null) refs.queuedAtMs = now();
+        const idempotencyKey = `glasses-wake:${refs.surfaceUuid}:${refs.eventId === null ? 0 : refs.eventId}`;
+        pushOutbox({
+          ...refs,
+          idempotencyKey,
+          failedAtMs: now(),
+          error: "no_dispatch_lane",
+        });
+        emitLifecycle("wake_unavailable_outboxed", "debug", { ...refs, idempotencyKey });
+      }
+      return { dispatched: false, reason: "no_dispatch_lane" };
+    }
+    if (!GLASSES_WAKE_ENABLED_ORIGINS.includes(refs.origin)) {
+      return suppress("origin_disabled", refs);
+    }
+    const sessionKey = refs.sessionKey;
+    if (!sessionKey) return suppress("no_session", refs);
+    if (isAgentTurnBusy(sessionKey)) {
+
+      return suppress("absorbed_by_active_turn", refs);
+    }
+    if (inFlightBySession.has(sessionKey)) {
+      emitLifecycle("wake_coalesced", "debug", refs);
+      return { dispatched: false, reason: "coalesced_into_inflight_wake" };
+    }
+    const lastWakeAt = lastWakeAtBySession.get(sessionKey);
+    if (Number.isFinite(lastWakeAt) && now() - lastWakeAt < wakeCooldownMs) {
+      return suppress("cooldown", refs);
+    }
+
+    if (refs.queuedAtMs === null) refs.queuedAtMs = now();
+    const message = buildWakeMessage(refs);
+    const idempotencyKey = `glasses-wake:${refs.surfaceUuid}:${refs.eventId === null ? 0 : refs.eventId}`;
+    const payload = { sessionKey, message, idempotencyKey };
+    lastWakeAtBySession.set(sessionKey, now());
+    const attempt = () => Promise.resolve(dispatchWake(payload));
+    const flight = attempt()
+      .catch(() => attempt())
+      .then(() => {
+        emitLifecycle("wake_dispatched", "debug", { ...refs, idempotencyKey });
+      })
+      .catch((err) => {
+
+        pushOutbox({
+          ...refs,
+          idempotencyKey,
+          failedAtMs: now(),
+          error: String((err && err.message) || err),
+        });
+        emitLifecycle("wake_dispatch_failed", "warn", { ...refs, idempotencyKey });
+      })
+      .finally(() => {
+        inFlightBySession.delete(sessionKey);
+      });
+    inFlightBySession.set(sessionKey, flight);
+    return { dispatched: true, idempotencyKey };
+  }
+
+  function peekWakeOutbox() {
+    return outbox.map((r) => ({ ...r }));
+  }
+
+  function drainWakeOutbox() {
+    return outbox.splice(0, outbox.length);
+  }
+
+  return { onParkedGesture, peekWakeOutbox, drainWakeOutbox };
+}
+
+export default { createGlassesWakeController, createAgentTurnTracker, buildWakeMessage, sanitizeWakeToken, GLASSES_WAKE_ENABLED_ORIGINS };

package/dist/tools/session-title-tool.js

@@ -1,5 +1,5 @@
 export const SESSION_TITLE_LIMITS = {
-  titleMax: 55, // 64 SDK list-item cap minus ~9 chars headroom for "<time> - " prefix
+  titleMax: 55,
 };
 
 export const sessionTitleParametersSchema = {
@@ -51,12 +51,7 @@ function isEvenAiDedicatedKey(sessionKey) {
 }
 
 function gateReason(sessionKey, deps) {
-  // Explicit-rename-only: the Neural Session Names toggle governs AUTOMATIC
-  // titling (the distiller), not user-requested renames, so feature_disabled is
-  // gone. session_user_locked is gone too — a user who already named a session
-  // must be able to rename it again (the lock only blocks the distiller).
-  // The structural no_active_session / EvenAI-renamable guards live in the
-  // handler body. Only the no-user-message guard remains here.
+
   if (
     typeof deps.hasRecordedUserMessage === "function" &&
     !deps.hasRecordedUserMessage(sessionKey)

package/dist/tools/session-title-tool.test.js

@@ -26,7 +26,7 @@ test("explicit rename passes origin user_tool", async () => {
 test("a user-locked session can STILL be renamed via the tool", async () => {
   const d = deps({
     setSessionTitle: (k, t, o) => {
-      // service-layer would allow user_tool over a lock; tool must not pre-block
+
       return { ok: true };
     },
   });

package/dist/version.js

@@ -1,2 +1,3 @@
-export const PLUGIN_VERSION = "1.3.2";
-export const REQUIRES_CLIENT_VERSION = "1.3.2";
+export const PLUGIN_VERSION = "1.3.4";
+export const REQUIRES_CLIENT_VERSION = "1.3.4";
+export const BUILD_INPUT_HASH = "sha256:2e70aa3160e383e95d494d26249e07351ccc4d5372ff13e40c532a5c408e21d0";

package/openclaw.plugin.json

@@ -28,6 +28,11 @@
       "help": "Optional. Enables Soniox speech-to-text for voice input.",
       "sensitive": true
     },
+    "cartesiaApiKey": {
+      "label": "Cartesia API key",
+      "help": "Optional. Enables Cartesia Ink-2 speech-to-text for voice input.",
+      "sensitive": true
+    },
     "evenAiEnabled": {
       "label": "Enable Even AI",
       "help": "Routes Even AI agent requests through OcuClaw. Requires evenAiToken when enabled."
@@ -45,7 +50,7 @@
     },
     "sessionTitleModel": {
       "label": "Session-title model",
-      "help": "Optional model override (\"provider/model\") for the background session-title distiller. Leave blank to use your normal model.",
+      "help": "Optional model override (\"provider/model\") for the background session-title distiller. This is a lightweight background task, so a small, fast, inexpensive model is a good choice (e.g. anthropic/claude-haiku-4-5). Leave blank to use your normal model.",
       "advanced": true
     },
     "evenAiRoutingMode": {
@@ -64,13 +69,8 @@
       "advanced": true
     },
     "sessionLimit": {
-      "label": "Concurrent session limit",
-      "help": "Maximum simultaneous client sessions accepted by the relay.",
-      "advanced": true
-    },
-    "debugPayloadMaxBytes": {
-      "label": "Debug payload size limit",
-      "help": "Maximum byte size for debug payloads recorded for debugctl.",
+      "label": "WebUI session list size",
+      "help": "Recent sessions fetched for the WebUI switcher/search list. Glasses clamp to their own item-count cap.",
       "advanced": true
     },
     "debugNoisyPolicies": {
@@ -83,6 +83,26 @@
       "help": "Allow debugctl-style external tools to call debug-set, debug-dump, and remote-control.",
       "advanced": true
     },
+    "allowDebugUpload": {
+      "label": "Allow debug-trace upload",
+      "help": "Allow the relay to assemble user-initiated debug-trace bundles and hand them to the phone for upload. Requires External debug tools. Off by default.",
+      "advanced": true
+    },
+    "debugUploadMaxZipBytes": {
+      "label": "Debug upload max zip size (bytes)",
+      "help": "Maximum compressed (uploaded) bundle size; the binding upload cap. Oldest events are trimmed until the zip fits.",
+      "advanced": true
+    },
+    "debugUploadCapturePreset": {
+      "label": "Debug upload capture preset (override)",
+      "help": "Optional override of the always-armed debug-upload capture category list.",
+      "advanced": true
+    },
+    "debugBundleSaveDir": {
+      "label": "Debug bundle save directory",
+      "help": "Directory for locally-saved debug bundles. Empty = ~/.openclaw/ocuclaw-debug-bundles.",
+      "advanced": true
+    },
     "evenAiRequestTimeoutMs": {
       "label": "Even AI request timeout (ms) (deprecated)",
       "advanced": true
@@ -136,14 +156,13 @@
       "sessionLimit": {
         "type": "integer",
         "minimum": 1,
-        "default": 10,
-        "description": "Maximum concurrent client sessions accepted by the relay."
+        "default": 80,
+        "description": "Number of recent sessions fetched for the WebUI session switcher/search list (glasses clamp to their own item-count cap)."
       },
       "debugPayloadMaxBytes": {
         "type": "integer",
         "minimum": 1,
-        "default": 2048,
-        "description": "Maximum byte size for individual debug payloads recorded for debugctl."
+        "description": "Deprecated and ignored: debug payload truncation was removed (2026-05-13); this key has no effect. Retained in the schema only so existing configs that still set it continue to validate."
       },
       "debugNoisyPolicies": {
         "anyOf": [
@@ -164,10 +183,38 @@
         "default": false,
         "description": "Allow debugctl-style external debug tools to use debug-set, debug-dump, and remote-control."
       },
+      "allowDebugUpload": {
+        "type": "boolean",
+        "default": false,
+        "description": "Allow the relay to assemble user-initiated debug-trace upload bundles and hand them to the phone (requires externalDebugToolsEnabled). Off by default."
+      },
+      "debugUploadMaxZipBytes": {
+        "type": "integer",
+        "minimum": 100000,
+        "maximum": 4300000,
+        "default": 4000000,
+        "description": "Maximum compressed (uploaded) bundle size (bytes); the binding upload cap, kept under the upload backend's limit. Oldest events are trimmed until the zip fits."
+      },
+      "debugUploadCapturePreset": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "Optional override of the always-armed debug-upload capture preset (list of category names)."
+      },
+      "debugBundleSaveDir": {
+        "type": "string",
+        "default": "",
+        "description": "Directory for locally-saved debug bundles; empty = ~/.openclaw/ocuclaw-debug-bundles."
+      },
       "sonioxApiKey": {
         "type": "string",
         "description": "Optional Soniox API key. Enables Soniox speech-to-text for voice input."
       },
+      "cartesiaApiKey": {
+        "type": "string",
+        "description": "Optional Cartesia API key. Enables Cartesia Ink-2 speech-to-text for voice input."
+      },
       "evenAiEnabled": {
         "type": "boolean",
         "default": false,
@@ -234,7 +281,7 @@
       },
       "sessionTitleModel": {
         "type": "string",
-        "description": "Optional model override (\"provider/model\") for the background session-title distiller. When absent, the user's normal model is used."
+        "description": "Optional model override (\"provider/model\") for the background session-title distiller. This is a lightweight background task, so a small, fast, inexpensive model is a good choice (e.g. anthropic/claude-haiku-4-5). When absent, the user's normal model is used."
       }
     },
     "if": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ocuclaw",
-  "version": "1.3.2",
-  "requiresClientVersion": "1.3.2",
+  "version": "1.3.4",
+  "requiresClientVersion": "1.3.4",
   "description": "OcuClaw for Even Realities G2 smart glasses.",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,6 +34,7 @@
     }
   },
   "dependencies": {
+    "fflate": "^0.8.3",
     "marked": "^17.0.2",
     "undici": "^6.26.0",
     "ws": "^8.19.0"

package/skills/glasses-ui/SKILL.md

@@ -6,7 +6,7 @@ user-invocable: false
 
 # Authoring glasses surfaces with `render_glasses_ui`
 
-`render_glasses_ui` paints an interactive surface on the user's Even G2 HUD instead of a text reply. The call blocks until the user selects, dismisses, or backs out. This skill is the source of truth for **authoring** surfaces; the tool description is deliberately lean.
+`render_glasses_ui` paints an interactive surface on the user's Even G2 HUD instead of a text reply. Think in two verbs: the render **paints** (the surface lives on glass, ticking, until the user exits or its refresh budget ends) and the call carries **one one-shot listen** (a bounded window in which a tap resolves your call live). The paint outlives the listen by design. This skill is the source of truth for **authoring** surfaces; the tool description is deliberately lean.
 
 ## Before you author: is the tool loaded?
 
@@ -142,6 +142,20 @@ render_glasses_ui({
 })
 ```
 
+## The interaction window (the listen)
+
+Every call carries **one one-shot listen**: the host waits **90 seconds by default** for the user to act, **up to 600000 ms (10 min) via the optional `timeoutMs` param**. Pass `timeoutMs: 300000–600000` when you expect the user to read or decide; omit it for fire-and-forget paints; never go below 60000 for anything interactive. The listen is **never renewed automatically** — re-rendering opens a fresh one.
+
+When the listen ends without a tap you get a **non-terminal** `{ result: "window_expired", surface_still_live: true }`. **This is not an error and not a paint event** — the surface stays on glass and keeps ticking. From there:
+
+- Taps now **park** (the user sees their tap acknowledged; nothing is lost). Re-render the same surface (`update: "patch"`) to collect parked taps in this run — chain a couple of these listens if you are actively waiting, then stop.
+- Or simply **end your turn** — parked taps **wake you** (one agent turn per real parked gesture, delivered as a refs-only plugin notification; re-render to collect) or ride your next turn. Ending your turn with a surface parked is a normal, cheap state, not an abandonment.
+- **Silence-as-consent**: the window doubles as a default-action deadline. Put the deadline in the body copy ("Merging in 5 min unless you stop me"), give it a matching `timeoutMs`, and treat `window_expired` as consent.
+
+Parked deliveries arrive annotated: `surfaceUuid`, `eventId`, `origin`, `actor`, `queuedAtMs`, `parkedForMs`. For taps that **actuate** something (sell/approve/unlock), declare `staleAfterMs` per render — a tap parked longer arrives with `stale: true`: treat it as a re-confirm prompt, **never** execute it as-is.
+
+(The `await`/listen-without-repaint verb namespace is reserved for a future version — don't repurpose those words in surface copy or tooling.)
+
 ## Outcomes (the `result` you get back)
 
 | result | meaning |
@@ -149,15 +163,17 @@ render_glasses_ui({
 | `selected` | user picked a list item; `selected_index` + `selected_text` returned |
 | `back` | user double-tapped above the root; they want to revise — re-render the previous step or pivot |
 | `dismissed` | dismissed at root, or no selection made |
-| `timeout` | no interaction within the window (non-refresh default 30 min; refresh ends at `maxDurationMs`) |
+| `window_expired` | **non-terminal** — the listen ended, the surface is still live; taps park (see the interaction-window section) |
+| `timeout` | terminal hygiene cap (rare); a refresh surface ends at `maxDurationMs` |
 | `recipe_failed` | refresh only — initial smoke tick failed, the consecutive-failure breaker fired, or `onError:stop`; `failureReason` carries the last error |
 | `glasses_disconnected` | refresh only — the glasses client dropped mid-cron |
 
-Refresh results also carry: `ticks: { count, succeeded, failed, lastSuccessAt, lastFailureAt? }`, `lastBody`, `lastItems`, and `failureReason` (on `recipe_failed`).
+Every delivery carries the surface's durable `surfaceUuid` plus `origin` (`gesture` for wearer actions, `system` for plugin-initiated outcomes) and an `actor` slot. Refresh results also carry: `ticks: { count, succeeded, failed, lastSuccessAt, lastFailureAt? }`, `lastBody`, `lastItems`, and `failureReason` (on `recipe_failed`).
 
 ## Quick reference
 
 - Pick the **lowest tier**: host metrics → `system-stats`; pure data API → `http` (not enabled yet). Needs interpretation → render once from your turn.
 - `update` default is `replace` (in-place). Use `push` to drill in without losing the parent; `patch` to edit fields while the cron keeps ticking.
+- The listen is one-shot: default 90 s, `timeoutMs` up to 600000 (use 300000–600000 for read-or-decide). `window_expired` ≠ error — re-render to collect parked taps, or end your turn (they wake you / ride the next turn).
 - `intervalMs` ≥ 1000. Read `failureReason` on `recipe_failed` and fix the recipe.
 - After a surface resolves, a short text reply exits to chat; another render replaces; silence lets it linger.