ocuclaw 1.3.2 → 1.3.3

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

@@ -19,19 +19,109 @@ export function isTerminalOutcome(outcome) {
   return !!(outcome && typeof outcome.result === "string" && TERMINAL_RESULTS.has(outcome.result));
 }
 
+// Provenance enum for GlassEvents and wake envelopes (roadmap 6b, §2.6).
+// Only "gesture" is an enabled wake origin at launch; the others reserve the
+// event-to-wake categories (schedule/threshold/system) so enabling them later
+// is a policy change, not a schema migration.
+export const GLASS_EVENT_ORIGINS = ["gesture", "schedule", "threshold", "system"];
+
+// Session keys reach the store in two forms: the canonical agent ctx form
+// ("agent:<id>:<key>", what registerTool factories and agent_end hooks see)
+// and the stripped relay form ("<key>", what relay-side callbacks like the
+// glasses-disconnect drain carry). The suffix is the identity; the prefix is
+// routing. Normalizing at the store boundary makes every caller agnostic —
+// the same lesson as the 6f busy-tracker key fix (drift #2, `0cc639b9`).
+export function normalizeGlassesSessionKey(key) {
+  return typeof key === "string" ? key.replace(/^agent:[^:]+:/, "") : key;
+}
+
 export function createSurfaceStore(deps = {}) {
+  // Census identity: every store instance carries a storeId so lifecycle
+  // traces can tell WHICH plugin-load context's store handled a render/reap
+  // (drift #3, 2026-06-12: a queued wake run's collect landed in a sibling
+  // context's empty store and minted a phantom root — invisible without this).
+  const storeId =
+    typeof deps.storeId === "string" && deps.storeId
+      ? deps.storeId
+      : `st-${Math.random().toString(36).slice(2, 8)}`;
+  const emitLifecycle =
+    typeof deps.emitLifecycle === "function" ? deps.emitLifecycle : () => {};
   const pauseCron = typeof deps.pauseCron === "function" ? deps.pauseCron : () => {};
   const resumeCron = typeof deps.resumeCron === "function" ? deps.resumeCron : () => {};
   const stopCron = typeof deps.stopCron === "function" ? deps.stopCron : () => {};
+  const now = typeof deps.now === "function" ? deps.now : Date.now;
   const mintSurfaceId =
     typeof deps.mintSurfaceId === "function"
       ? deps.mintSurfaceId
       : () => `ui-${Math.random().toString(36).slice(2, 10)}`;
+  const mintUuid =
+    typeof deps.mintUuid === "function"
+      ? deps.mintUuid
+      : () => `su-${Math.random().toString(36).slice(2, 10)}${Math.random().toString(36).slice(2, 6)}`;
   // surfaceId -> { sessionKey, kind, pending: (resolver|null), lastContent,
-  //               state, queuedEvent, exitLatched }
+  //               state, queuedEvent, exitLatched, uuid, events, queueMode }
   const bySurface = new Map();
   const stackBySession = new Map(); // sessionKey -> [surfaceId, ...] (bottom→top)
 
+  // --- Parked-outcome event log + dead-letter (roadmap 6a, §2.6) ---
+  // Nonterminal outcomes append to a per-surface GlassEvent log; "latest" is
+  // the default read-time delivery reducer ("log" declarable per surface).
+  // Reap paths (drain/exit/popBack) hand undelivered events to a per-session
+  // dead-letter instead of destroying them: a ✓-acked tap must NEVER silently
+  // disappear (the 2026-06-12 panel's fatal). Wake/voicemail legs (6f/7b)
+  // drain the dead-letter; this wave only guarantees survival.
+  const DEAD_LETTER_EVENT_CAP = 32; // per session, FIFO eviction
+  const SURFACE_EVENT_LOG_CAP = 32; // per surface, FIFO eviction
+  const deadLetterBySession = new Map(); // sessionKey -> [{surfaceUuid, surfaceId, events, reason, reapedAtMs}]
+  let eventSeq = 0;
+
+  function deadLetterFor(sessionKey) {
+    let list = deadLetterBySession.get(sessionKey);
+    if (!list) { list = []; deadLetterBySession.set(sessionKey, list); }
+    return list;
+  }
+
+  function deadLetterEntryEvents(sessionKey, surfaceId, entry, reason) {
+    // A latched terminal means the wearer ended the surface — parked
+    // nonterminals beneath it are no longer intent to deliver.
+    if (!entry || entry.exitLatched || !entry.events || entry.events.length === 0) return;
+    const eventIds = entry.events.map((e) => e.eventId);
+    const list = deadLetterFor(sessionKey);
+    list.push({
+      surfaceUuid: entry.uuid,
+      surfaceId,
+      events: entry.events,
+      reason,
+      reapedAtMs: now(),
+      // The surface's declared staleness window travels with the reaped
+      // events so the 6f/7b consumers (wake/voicemail) can frame age honestly.
+      staleAfterMs: Number.isFinite(entry.staleAfterMs) ? entry.staleAfterMs : null,
+    });
+    entry.events = [];
+    // Reap-path observability: a ✓-acked event leaving the live queue for the
+    // dead-letter must be traceable (the contract is "never silently lost").
+    emitLifecycle("dead_letter_appended", "debug", {
+      sessionKey,
+      surfaceId,
+      surfaceUuid: entry.uuid,
+      reason,
+      eventIds,
+      count: eventIds.length,
+    });
+    let total = list.reduce((n, r) => n + r.events.length, 0);
+    while (total > DEAD_LETTER_EVENT_CAP && list.length) {
+      const oldest = list[0];
+      const overflow = total - DEAD_LETTER_EVENT_CAP;
+      if (oldest.events.length <= overflow) {
+        total -= oldest.events.length;
+        list.shift();
+      } else {
+        oldest.events.splice(0, overflow);
+        total -= overflow;
+      }
+    }
+  }
+
   function stackFor(sessionKey) {
     let s = stackBySession.get(sessionKey);
     if (!s) { s = []; stackBySession.set(sessionKey, s); }
@@ -53,10 +143,24 @@ export function createSurfaceStore(deps = {}) {
       state: "visible_pending",
       queuedEvent: prior ? prior.queuedEvent : null,
       exitLatched: prior ? !!prior.exitLatched : false,
+      // Durable identity + parked-event log carry forward through replace
+      // (same surfaceId, same surface as far as the wearer is concerned).
+      uuid: prior ? prior.uuid : mintUuid(),
+      events: prior ? prior.events : [],
+      queueMode: prior && prior.queueMode === "log" ? "log" : "latest",
+      // Per-render declaration (NOT carried through replace): register() sets
+      // it from each render's meta, so the latest render's spec governs.
+      staleAfterMs: null,
+      // 7a: title carries forward through replace (same surface, wearer continuity).
+      // awaitingAgentResponse resets on a fresh entry — a new render opens a new
+      // window so markerFor returns "listening" anyway.
+      title: prior ? prior.title : null,
+      awaitingAgentResponse: false,
     };
   }
 
-  function register(sessionKey, surfaceId, meta) {
+  function register(rawSessionKey, surfaceId, meta) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
     return new Promise((resolve) => {
       const existing = bySurface.get(surfaceId);
       if (existing) {
@@ -66,16 +170,36 @@ export function createSurfaceStore(deps = {}) {
         // onReattached flushes any queued event / latched exit.
         existing.pending = resolve;
         if (meta && meta.kind) existing.kind = meta.kind;
+        if (meta && (meta.queueMode === "log" || meta.queueMode === "latest")) {
+          existing.queueMode = meta.queueMode;
+        }
+        existing.staleAfterMs = meta && Number.isFinite(meta.staleAfterMs) ? meta.staleAfterMs : null;
+        if (meta && typeof meta.title === "string") existing.title = meta.title;
+        existing.awaitingAgentResponse = false; // a fresh render opens a new window
         existing.sessionKey = sessionKey;
         existing.state = "visible_pending";
         return;
       }
       const entry = makeEntry(sessionKey, meta && meta.kind ? meta.kind : null);
+      if (meta && (meta.queueMode === "log" || meta.queueMode === "latest")) {
+        entry.queueMode = meta.queueMode;
+      }
+      entry.staleAfterMs = meta && Number.isFinite(meta.staleAfterMs) ? meta.staleAfterMs : null;
+      if (meta && typeof meta.title === "string") entry.title = meta.title;
       entry.pending = resolve;
       bySurface.set(surfaceId, entry);
     });
   }
 
+  // Every delivered outcome carries the surface's durable identity (roadmap
+  // 6b): agents and the 6f wake/voicemail consumers key on surfaceUuid, never
+  // on the plugin-internal surfaceId. Additive only — caller fields win.
+  function decorateDelivery(entry, outcome) {
+    if (!outcome || typeof outcome !== "object" || Array.isArray(outcome)) return outcome;
+    if (outcome.surfaceUuid !== undefined) return outcome;
+    return { ...outcome, surfaceUuid: entry.uuid };
+  }
+
   function resolve(surfaceId, outcome) {
     const entry = bySurface.get(surfaceId);
     if (!entry || !entry.pending) return false;
@@ -83,10 +207,14 @@ export function createSurfaceStore(deps = {}) {
     entry.pending = null; // settle the call; surface entry persists
     if (isTerminalOutcome(outcome)) {
       entry.state = "exiting";
+      entry.awaitingAgentResponse = false;
     } else {
       entry.state = "visible_awaiting_agent";
+      // A wearer gesture (selected/back) means the agent is now responding;
+      // a window_expired resolve is the timer, not the wearer → parked.
+      entry.awaitingAgentResponse = !!(outcome && outcome.result !== "window_expired");
     }
-    pending(outcome);
+    pending(decorateDelivery(entry, outcome));
     return true;
   }
 
@@ -103,14 +231,47 @@ export function createSurfaceStore(deps = {}) {
   // resolve any in-flight pending call; Task 11 extends them to also stop
   // crons and clear the per-session stack. They are the only resolve path that
   // also DELETES surfaces (terminal teardown), unlike resolve() above.
-  function drainSession(sessionKey, outcome) {
+  // Drains are plugin/host-initiated by definition — stamp origin "system"
+  // (never a wearer gesture) unless the caller already typed it.
+  function decorateDrainOutcome(entry, outcome) {
+    if (!outcome || typeof outcome !== "object" || Array.isArray(outcome)) return outcome;
+    return decorateDelivery(entry, {
+      ...outcome,
+      origin: typeof outcome.origin === "string" ? outcome.origin : "system",
+    });
+  }
+
+  function drainSession(rawSessionKey, outcome) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
     let n = 0;
     for (const [surfaceId, entry] of [...bySurface]) {
       if (entry.sessionKey !== sessionKey) continue;
       const pending = entry.pending;
       entry.pending = null;
+      deadLetterEntryEvents(sessionKey, surfaceId, entry, "drain_session");
       bySurface.delete(surfaceId);
-      if (pending) { pending(outcome); n += 1; }
+      if (pending) { pending(decorateDrainOutcome(entry, outcome)); n += 1; }
+    }
+    return n;
+  }
+
+  // Settle still-pending calls for a session WITHOUT tearing anything down:
+  // entries, parked events, crons and the stack all persist (surfaces are
+  // DESIGNED to outlive runs — resolve ≠ teardown). This is the run-teardown
+  // safety net's correct scope: no leaked pending call / orphan tool_use,
+  // and no destruction of parked wearer intent (drift #3, 2026-06-12).
+  function settlePending(rawSessionKey, outcome) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
+    let n = 0;
+    for (const [, entry] of bySurface) {
+      if (entry.sessionKey !== sessionKey || !entry.pending) continue;
+      const pending = entry.pending;
+      entry.pending = null;
+      // The call leaked past its run; the surface stays live and collectable,
+      // exactly like the post-window_expired parked state.
+      entry.state = "visible_awaiting_agent";
+      pending(decorateDrainOutcome(entry, outcome));
+      n += 1;
     }
     return n;
   }
@@ -120,8 +281,9 @@ export function createSurfaceStore(deps = {}) {
     for (const [surfaceId, entry] of [...bySurface]) {
       const pending = entry.pending;
       entry.pending = null;
+      deadLetterEntryEvents(entry.sessionKey, surfaceId, entry, "drain_all");
       bySurface.delete(surfaceId);
-      if (pending) { pending(outcome); n += 1; }
+      if (pending) { pending(decorateDrainOutcome(entry, outcome)); n += 1; }
     }
     return n;
   }
@@ -131,16 +293,118 @@ export function createSurfaceStore(deps = {}) {
     return entry ? entry.state : null;
   }
 
-  function queueEvent(surfaceId, event) {
+  function queueEvent(surfaceId, event, opts) {
     const entry = bySurface.get(surfaceId);
     if (!entry) return false;
     if (isTerminalOutcome(event)) {
       entry.exitLatched = true; // latched exit beats any queued nonterminal
       entry.queuedEvent = event;
-    } else if (!entry.exitLatched) {
-      entry.queuedEvent = event; // last-wins among nonterminals
+      return { ok: true, eventId: ++eventSeq, surfaceUuid: entry.uuid, kind: "terminal_latch" };
     }
-    return true;
+    if (entry.exitLatched) {
+      // Path D: a wearer gesture on a SYSTEM-origin latch (cron maxDuration death,
+      // stamped origin:"system" at tool.ts:945) is NOT the wearer ending the
+      // surface — revive it. Clear the latch and fall through to the normal append
+      // (truthy receipt → ✓-ack → wake; the next render takes onReattached's deliver
+      // path, not discarded_for_exit). A GESTURE-origin latch keeps dropping (the
+      // wearer really ended it). Mirrors onReattached's forgiveness (surfaces.ts:373-377).
+      const latched = entry.queuedEvent;
+      const latchedOrigin = latched && typeof latched.origin === "string" ? latched.origin : "gesture";
+      if (latchedOrigin === "gesture") {
+        // Wearer-ended surface — drop; never ✓-ack a dead tap.
+        return false;
+      }
+      entry.exitLatched = false;
+      entry.queuedEvent = null;
+      // fall through to append the reviving gesture below
+    }
+    const record = {
+      eventId: ++eventSeq,
+      surfaceUuid: entry.uuid,
+      origin: opts && typeof opts.origin === "string" ? opts.origin : "gesture",
+      actor: opts && typeof opts.actor === "string" ? opts.actor : "wearer",
+      queuedAtMs: now(),
+      deliveredVia: null,
+      outcome: event,
+    };
+    entry.events.push(record);
+    if (entry.events.length > SURFACE_EVENT_LOG_CAP) {
+      entry.events.splice(0, entry.events.length - SURFACE_EVENT_LOG_CAP);
+    }
+    entry.queuedEvent = event; // legacy newest-nonterminal mirror (carry-forward path)
+    return { ok: true, eventId: record.eventId, surfaceUuid: entry.uuid };
+  }
+
+  function titleOf(surfaceId) {
+    const entry = bySurface.get(surfaceId);
+    return entry ? entry.title : null;
+  }
+
+  // Plugin-authoritative presence marker (roadmap 7a). Pure function of two
+  // store facts: is a listen window open, and is anything in flight (a queued
+  // tap OR the agent responding to a just-delivered gesture). Glyphs are
+  // mapped client-side; the plugin only emits these enum strings.
+  function markerFor(surfaceId) {
+    const entry = bySurface.get(surfaceId);
+    if (!entry) return null;
+    if (entry.pending) return "listening";
+    if ((entry.events && entry.events.length > 0) || entry.awaitingAgentResponse) return "inflight";
+    return "parked";
+  }
+
+  // 7a: called by the agent_end hook to flip inflight→parked for the session's
+  // surfaces when the agent turn ends without a new render (silent end).
+  function clearAwaitingResponse(rawSessionKey) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
+    for (const [, entry] of bySurface) {
+      if (entry.sessionKey === sessionKey) entry.awaitingAgentResponse = false;
+    }
+  }
+
+  // 7a: compose the breadcrumb from the session's stack of titles, separator " › ".
+  // Returns null when the session has no stack, is empty, or has no titled surfaces.
+  function breadcrumbFor(rawSessionKey) {
+    const s = stackBySession.get(normalizeGlassesSessionKey(rawSessionKey));
+    if (!s || s.length === 0) return null;
+    const titles = s
+      .map((id) => { const e = bySurface.get(id); return e && typeof e.title === "string" ? e.title : null; })
+      .filter((t) => typeof t === "string" && t.length > 0);
+    return titles.length ? titles.join(" › ") : null;
+  }
+
+  function uuidOf(surfaceId) {
+    const entry = bySurface.get(surfaceId);
+    return entry ? entry.uuid : null;
+  }
+
+  function peekEvents(surfaceId) {
+    const entry = bySurface.get(surfaceId);
+    return entry ? [...entry.events] : [];
+  }
+
+  // Read-time delivery reducer (6a): "latest" collapses to the newest
+  // nonterminal (the pre-6a delivery semantics); "log" exposes the ordered
+  // sequence for consumers that drain it whole (wake/voicemail, v2 collect).
+  function reduceForDelivery(surfaceId) {
+    const entry = bySurface.get(surfaceId);
+    if (!entry) return null;
+    if (entry.queueMode === "log") {
+      return { mode: "log", events: [...entry.events] };
+    }
+    const newest = entry.events.length ? entry.events[entry.events.length - 1] : null;
+    return { mode: "latest", outcome: newest ? newest.outcome : null };
+  }
+
+  function peekDeadLetter(sessionKey) {
+    const list = deadLetterBySession.get(normalizeGlassesSessionKey(sessionKey));
+    return list ? list.map((r) => ({ ...r, events: [...r.events] })) : [];
+  }
+
+  function drainDeadLetter(rawSessionKey) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
+    const list = deadLetterBySession.get(sessionKey) || [];
+    deadLetterBySession.set(sessionKey, []);
+    return list;
   }
 
   function isExitLatched(surfaceId) {
@@ -151,40 +415,89 @@ export function createSurfaceStore(deps = {}) {
   function onReattached(surfaceId) {
     const entry = bySurface.get(surfaceId);
     if (!entry) return "no_surface";
+    let staleLatchDropped = false;
     if (entry.exitLatched) {
-      // A terminal latched during the agent's turn. Discard this render and
-      // resolve the freshly-established pending call (the re-attach render's
-      // promise) with the latched terminal outcome so the tool call settles
-      // instead of hanging, then tear down.
-      entry.state = "exiting";
-      const terminal = entry.queuedEvent || { result: "dismissed" };
-      entry.queuedEvent = null;
-      if (entry.pending) {
-        const pending = entry.pending;
-        entry.pending = null;
-        pending(terminal);
+      // Generation gate (roadmap 6d, panel amendment 5): any latch read here
+      // was by construction queued under a PRIOR call (queueEvent only
+      // latches while no call is pending). A SYSTEM-origin terminal — a
+      // cron's own maxDuration timeout / recipe_failed summary — is plugin
+      // noise relative to the agent's fresh render and must NOT consume the
+      // fresh call's window (HW 2026-06-11: a 7-min-stale cron `timeout`
+      // ate a fresh 10-min call in 2.2s). Drop it and proceed; the fresh
+      // render recycles the slot, which is the teardown the latch wanted.
+      // GESTURE terminals (and legacy un-stamped ones — honoring a teardown
+      // is the safe default) keep the discard-for-exit contract: the wearer
+      // ended the surface and the fresh render must not resurrect it.
+      const latched = entry.queuedEvent;
+      const latchedOrigin =
+        latched && typeof latched.origin === "string" ? latched.origin : "gesture";
+      if (latchedOrigin !== "gesture") {
+        entry.exitLatched = false;
+        entry.queuedEvent = null;
+        staleLatchDropped = true;
+      } else {
+        // A terminal latched during the agent's turn. Discard this render and
+        // resolve the freshly-established pending call (the re-attach render's
+        // promise) with the latched terminal outcome so the tool call settles
+        // instead of hanging, then tear down. Parked nonterminals beneath the
+        // latch are dropped (the wearer ended the surface), not dead-lettered.
+        entry.state = "exiting";
+        const terminal = entry.queuedEvent || { result: "dismissed" };
+        entry.queuedEvent = null;
+        entry.events = [];
+        if (entry.pending) {
+          const pending = entry.pending;
+          entry.pending = null;
+          pending(decorateDelivery(entry, terminal));
+        }
+        return "discarded_for_exit";
       }
-      return "discarded_for_exit";
     }
     entry.state = "reattached";
-    const queued = entry.queuedEvent;
+    // "latest"-reducer delivery (unchanged since 6a): the newest nonterminal
+    // resolves the re-attached call and the log drains. 6b: the delivery is
+    // decorated with the log record's identity + provenance + age, and — when
+    // the render declared staleAfterMs — an annotate-only stale flag (the tap
+    // is still delivered; degrading a stale actuating tap to a re-confirm is
+    // the agent's job, taught in the skill).
+    const newest = entry.events.length ? entry.events[entry.events.length - 1] : null;
+    let delivered = null;
+    if (newest) {
+      const parkedForMs = Math.max(0, now() - newest.queuedAtMs);
+      delivered = {
+        ...newest.outcome,
+        surfaceUuid: entry.uuid,
+        eventId: newest.eventId,
+        origin: newest.origin,
+        actor: newest.actor || "wearer",
+        queuedAtMs: newest.queuedAtMs,
+        parkedForMs,
+      };
+      if (Number.isFinite(entry.staleAfterMs) && parkedForMs > entry.staleAfterMs) {
+        delivered.stale = true;
+      }
+    } else if (entry.queuedEvent) {
+      delivered = decorateDelivery(entry, entry.queuedEvent);
+    }
     entry.queuedEvent = null;
-    if (queued && entry.pending) {
+    entry.events = [];
+    if (delivered && entry.pending) {
       const pending = entry.pending;
       entry.pending = null;
       entry.state = "visible_awaiting_agent";
-      pending(queued);
+      entry.awaitingAgentResponse = true; // 7a: a delivered queued gesture = agent now responding
+      pending(delivered);
     }
-    return "reattached";
+    return staleLatchDropped ? "reattached_stale_latch_dropped" : "reattached";
   }
 
   function topSurfaceId(sessionKey) {
-    const s = stackBySession.get(sessionKey);
+    const s = stackBySession.get(normalizeGlassesSessionKey(sessionKey));
     return s && s.length ? s[s.length - 1] : null;
   }
 
   function stackDepth(sessionKey) {
-    const s = stackBySession.get(sessionKey);
+    const s = stackBySession.get(normalizeGlassesSessionKey(sessionKey));
     return s ? s.length : 0;
   }
 
@@ -197,7 +510,8 @@ export function createSurfaceStore(deps = {}) {
   // never supplies a surfaceId (spec §Core model — the plugin owns them,
   // keyed by session + stack). Returns { mode, surfaceId } so the caller can
   // render against the bound id.
-  function applyRender(sessionKey, params) {
+  function applyRender(rawSessionKey, params) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
     const stack = stackFor(sessionKey);
     const top = stack[stack.length - 1] || null;
     // First render in a session (empty stack): create a root at depth 1,
@@ -248,18 +562,28 @@ export function createSurfaceStore(deps = {}) {
     return { mode: "replace", surfaceId: top };
   }
 
-  function popBack(sessionKey) {
+  function popBack(rawSessionKey) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
     const stack = stackFor(sessionKey);
     const child = stack.pop();
-    if (child) { stopCron(child); bySurface.delete(child); }
+    if (child) {
+      stopCron(child);
+      deadLetterEntryEvents(sessionKey, child, bySurface.get(child), "pop_back");
+      bySurface.delete(child);
+    }
     const parent = stack[stack.length - 1] || null;
     if (parent) resumeCron(parent);
     return parent;
   }
 
-  function exit(sessionKey) {
+  function exit(rawSessionKey) {
+    const sessionKey = normalizeGlassesSessionKey(rawSessionKey);
     const stack = stackFor(sessionKey);
-    for (const id of stack) { stopCron(id); bySurface.delete(id); }
+    for (const id of stack) {
+      stopCron(id);
+      deadLetterEntryEvents(sessionKey, id, bySurface.get(id), "exit");
+      bySurface.delete(id);
+    }
     stackBySession.set(sessionKey, []);
     return true;
   }
@@ -269,9 +593,12 @@ export function createSurfaceStore(deps = {}) {
   }
 
   return {
-    register, resolve, hasSurface, isPending, drainSession, drainAll,
+    storeId,
+    register, resolve, hasSurface, isPending, drainSession, drainAll, settlePending,
     stateOf, queueEvent, isExitLatched, onReattached,
     applyRender, popBack, exit, topSurfaceId, stackDepth, sessionKeys, sessionForSurface,
+    uuidOf, titleOf, markerFor, clearAwaitingResponse, breadcrumbFor,
+    peekEvents, reduceForDelivery, peekDeadLetter, drainDeadLetter,
     _bySurface: bySurface,
   };
 }