@elizaos/ui 2.0.3-beta.2 → 2.0.3-beta.4

package/components/shell/shell-state.d.ts

@@ -1,4 +1,4 @@
-import type { ChatFailureKind, MessageAttachment } from "../../api";
+import type { ChatFailureKind, ConversationSecretRequest, MessageAttachment } from "../../api/index.js";
 /**
  * Shell phase for the device-shell foundation (HomePill + AssistantOverlay +
  * ChatSurface). Drives the pill's visual treatment.
@@ -21,5 +21,28 @@ export interface ShellMessage {
     reasoning?: string;
     /** Media attached to this turn — user uploads and agent-generated media. */
     attachments?: MessageAttachment[];
+    /** Pending secret / OAuth request (rendered as an actionable block). */
+    secretRequest?: ConversationSecretRequest;
+    /**
+     * Short topic labels for this turn (Stage-1 `topics`). Drives the transcript
+     * topic grouping + chips bar (#8928). Absent when the turn had no topic.
+     */
+    topics?: string[];
 }
+/**
+ * Max chat turns actually rendered in the shell transcript. Older turns stay in
+ * state (the agent's context is untouched) — this only bounds DOM nodes so a
+ * long thread can't jank scrolling, without pulling in a virtualizer. Gap 4 of
+ * #9141 (transcript windowing) builds on this seam.
+ */
+export declare const MAX_RENDERED_SHELL_MESSAGES = 80;
+/**
+ * Pure transcript-windowing decision (#9141 gap 4 seam). Drops empty turns —
+ * EXCEPT the in-flight assistant turn while a reply is streaming (phase ===
+ * "responding"), so its bubble can show the breathing dots anchored where the
+ * text will fill in — then keeps only the most recent `max` turns to bound DOM
+ * nodes. Pure + DOM-free so the cap + streaming-turn exception are unit-testable
+ * and any future virtualizer can reuse the same predicate.
+ */
+export declare function selectVisibleShellMessages(messages: readonly ShellMessage[], phase: ShellPhase, max?: number): ShellMessage[];
 //# sourceMappingURL=shell-state.d.ts.map

package/components/shell/shell-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shell-state.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/shell-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,MAAM,GACN,UAAU,GACV,WAAW,GACX,YAAY,CAAC;AAEjB,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACnC"}
+{"version":3,"file":"shell-state.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/shell-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,MAAM,GACN,UAAU,GACV,WAAW,GACX,YAAY,CAAC;AAEjB,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,wEAAwE;IACxE,aAAa,CAAC,EAAE,yBAAyB,CAAC;IAC1C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,KAAK,EAAE,UAAU,EACjB,GAAG,GAAE,MAAoC,GACxC,YAAY,EAAE,CAMhB"}

package/components/shell/shell-state.js

@@ -1 +1,19 @@
-export {};
+/**
+ * Max chat turns actually rendered in the shell transcript. Older turns stay in
+ * state (the agent's context is untouched) — this only bounds DOM nodes so a
+ * long thread can't jank scrolling, without pulling in a virtualizer. Gap 4 of
+ * #9141 (transcript windowing) builds on this seam.
+ */
+export const MAX_RENDERED_SHELL_MESSAGES = 80;
+/**
+ * Pure transcript-windowing decision (#9141 gap 4 seam). Drops empty turns —
+ * EXCEPT the in-flight assistant turn while a reply is streaming (phase ===
+ * "responding"), so its bubble can show the breathing dots anchored where the
+ * text will fill in — then keeps only the most recent `max` turns to bound DOM
+ * nodes. Pure + DOM-free so the cap + streaming-turn exception are unit-testable
+ * and any future virtualizer can reuse the same predicate.
+ */
+export function selectVisibleShellMessages(messages, phase, max = MAX_RENDERED_SHELL_MESSAGES) {
+    const kept = messages.filter((m) => m.content.trim() || (m.role === "assistant" && phase === "responding"));
+    return max > 0 && kept.length > max ? kept.slice(-max) : [...kept];
+}

package/components/shell/startup-shell-types.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
-import type { StartupErrorState } from "../../state/types";
+import type { StartupErrorState } from "../../state/types.js";
 export type StartupShellView = {
     kind: "error";
     error: StartupErrorState;

package/components/shell/topic-grouping.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Topic grouping for the chat transcript (#8928).
+ *
+ * Turns a flat message list into topic-clustered segments using the per-message
+ * `topics` stamped at Stage-1 (see `MessageMetadata.topics`). A message's
+ * dominant topic is its first label; a new segment begins when that dominant
+ * topic changes (the "topic break"). Messages with no topic inherit the current
+ * segment so the transcript never fragments on every untagged turn.
+ *
+ * Pure logic — the overlay/ChatView render the segments and a topic chips bar;
+ * this module is unit-testable in isolation.
+ */
+/** Minimal shape the grouping needs from a message. */
+export interface TopicTaggedMessage {
+    id: string;
+    topics?: string[];
+}
+/** A contiguous run of messages sharing a dominant topic. */
+export interface TopicSegment<T extends TopicTaggedMessage> {
+    /** Stable key for collapse state — the topic, or the first message id. */
+    key: string;
+    /** Dominant topic label, or null for an untitled leading run. */
+    topic: string | null;
+    messages: T[];
+}
+/** Maximum chips rendered in the topic bar before the rest are summarized. */
+export declare const MAX_TOPIC_CHIPS = 12;
+/**
+ * Group consecutive messages into topic segments. A new segment starts when a
+ * message's dominant topic differs from the current segment's topic; untagged
+ * messages extend the current segment.
+ */
+export declare function groupMessagesByTopic<T extends TopicTaggedMessage>(messages: readonly T[]): TopicSegment<T>[];
+/**
+ * Distinct channel topics across the transcript for the chips bar, ordered
+ * most-recent first, capped at {@link MAX_TOPIC_CHIPS}.
+ */
+export declare function deriveChannelTopics(messages: readonly TopicTaggedMessage[]): string[];
+//# sourceMappingURL=topic-grouping.d.ts.map

package/components/shell/topic-grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topic-grouping.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/topic-grouping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,uDAAuD;AACvD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,kBAAkB;IACxD,0EAA0E;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,EAAE,CAAC;CACf;AAED,8EAA8E;AAC9E,eAAO,MAAM,eAAe,KAAK,CAAC;AAWlC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,kBAAkB,EAC/D,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,YAAY,CAAC,CAAC,CAAC,EAAE,CA2BnB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GACtC,MAAM,EAAE,CAiBV"}

package/components/shell/topic-grouping.js

@@ -0,0 +1,81 @@
+/**
+ * Topic grouping for the chat transcript (#8928).
+ *
+ * Turns a flat message list into topic-clustered segments using the per-message
+ * `topics` stamped at Stage-1 (see `MessageMetadata.topics`). A message's
+ * dominant topic is its first label; a new segment begins when that dominant
+ * topic changes (the "topic break"). Messages with no topic inherit the current
+ * segment so the transcript never fragments on every untagged turn.
+ *
+ * Pure logic — the overlay/ChatView render the segments and a topic chips bar;
+ * this module is unit-testable in isolation.
+ */
+/** Maximum chips rendered in the topic bar before the rest are summarized. */
+export const MAX_TOPIC_CHIPS = 12;
+function dominantTopic(message) {
+    const topics = message.topics;
+    if (!Array.isArray(topics))
+        return null;
+    for (const topic of topics) {
+        if (typeof topic === "string" && topic.trim())
+            return topic.trim();
+    }
+    return null;
+}
+/**
+ * Group consecutive messages into topic segments. A new segment starts when a
+ * message's dominant topic differs from the current segment's topic; untagged
+ * messages extend the current segment.
+ */
+export function groupMessagesByTopic(messages) {
+    const segments = [];
+    for (const message of messages) {
+        const topic = dominantTopic(message);
+        const last = segments[segments.length - 1];
+        // Start a new segment on the first message, or when a tagged message
+        // introduces a different dominant topic than the current TITLED segment.
+        // A leading untitled run (last.topic === null) instead adopts the topic.
+        if (!last ||
+            (topic !== null && last.topic !== null && topic !== last.topic)) {
+            segments.push({
+                key: topic ?? `untitled-${message.id}`,
+                topic,
+                messages: [message],
+            });
+            continue;
+        }
+        last.messages.push(message);
+        // An untitled leading segment adopts the first topic it encounters.
+        if (last.topic === null && topic !== null) {
+            last.topic = topic;
+            last.key = topic;
+        }
+    }
+    return segments;
+}
+/**
+ * Distinct channel topics across the transcript for the chips bar, ordered
+ * most-recent first, capped at {@link MAX_TOPIC_CHIPS}.
+ */
+export function deriveChannelTopics(messages) {
+    const seen = new Set();
+    const ordered = [];
+    // Walk newest → oldest so the most recent topics lead.
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const topics = messages[i]?.topics;
+        if (!Array.isArray(topics))
+            continue;
+        for (const raw of topics) {
+            if (typeof raw !== "string")
+                continue;
+            const topic = raw.trim();
+            if (!topic || seen.has(topic))
+                continue;
+            seen.add(topic);
+            ordered.push(topic);
+            if (ordered.length >= MAX_TOPIC_CHIPS)
+                return ordered;
+        }
+    }
+    return ordered;
+}

package/components/shell/use-conversation-reset.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared "reset the conversation" action.
+ *
+ * Resets to a fresh greeted thread via the existing `handleNewConversation`
+ * path. A non-empty previous conversation is kept (it stays swipe-reachable);
+ * only an empty draft we just left is pruned, so resets don't pile up orphan
+ * conversations.
+ *
+ * Used by the main ChatView reset button; the overlay header reset routes
+ * through `useShellController.clearConversation`, which calls the same
+ * `handleNewConversation` so the behavior is identical everywhere.
+ */
+export declare function useConversationReset(): () => void;
+//# sourceMappingURL=use-conversation-reset.d.ts.map

package/components/shell/use-conversation-reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-reset.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/use-conversation-reset.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CAWjD"}

package/components/shell/use-conversation-reset.js

@@ -0,0 +1,25 @@
+import * as React from "react";
+import { useAppSelectorShallow } from "../../state/index.js";
+/**
+ * Shared "reset the conversation" action.
+ *
+ * Resets to a fresh greeted thread via the existing `handleNewConversation`
+ * path. A non-empty previous conversation is kept (it stays swipe-reachable);
+ * only an empty draft we just left is pruned, so resets don't pile up orphan
+ * conversations.
+ *
+ * Used by the main ChatView reset button; the overlay header reset routes
+ * through `useShellController.clearConversation`, which calls the same
+ * `handleNewConversation` so the behavior is identical everywhere.
+ */
+export function useConversationReset() {
+    // Granular shallow selector instead of useApp() so this hook only re-renders
+    // when the one field it reads changes, not on every app-store field update
+    // (#9141 gap 2 — useApp() → useAppSelector migration).
+    const { handleNewConversation } = useAppSelectorShallow((s) => ({
+        handleNewConversation: s.handleNewConversation,
+    }));
+    return React.useCallback(() => {
+        void handleNewConversation();
+    }, [handleNewConversation]);
+}

package/components/shell/use-pull-gesture.d.ts

@@ -1,20 +1,34 @@
 import * as React from "react";
 /**
- * Vertical pull/flick gesture detection for the homescreen shell.
+ * Pull/flick + swipe gesture detection for the homescreen shell.
  *
  * Drives the Claude/Whisper-Flow-style interactions: pull UP on the homescreen
  * to reveal the chat, pull DOWN (or flick up on the voice overlay) to dismiss.
- * Pure pointer-event logic — bind the returned handlers to any element. A
- * gesture fires on release when it crosses either a distance OR a velocity
- * threshold, so both deliberate drags and quick flicks register.
+ * Optionally also detects horizontal swipes (left/right) for navigating between
+ * conversations when the sheet is open. Pure pointer-event logic — bind the
+ * returned handlers to any element. A gesture fires on release when it crosses
+ * either a distance OR a velocity threshold, so both deliberate drags and quick
+ * flicks register.
+ *
+ * Axis lock: the gesture commits to a single axis (vertical OR horizontal) once
+ * movement crosses {@link AXIS_COMMIT_SLOP}px, so a horizontal swipe never
+ * fights the vertical pull and vice-versa. Pointer capture is deferred until
+ * commit, so a vertical scroll inside a horizontally-swipeable panel still
+ * scrolls natively (we only capture once the user clearly means to swipe).
  */
 export interface PullGestureOptions {
     /** Released after a drag/flick UP past threshold. */
     onPullUp?: () => void;
     /** Released after a drag/flick DOWN past threshold. */
     onPullDown?: () => void;
-    /** Live drag offset while pressed, in px. Positive = dragging up. */
+    /** Live vertical drag offset while pressed, in px. Positive = dragging up. */
     onDrag?: (offset: number) => void;
+    /** Released after a horizontal swipe LEFT past threshold. */
+    onSwipeLeft?: () => void;
+    /** Released after a horizontal swipe RIGHT past threshold. */
+    onSwipeRight?: () => void;
+    /** Live horizontal drag offset while pressed, in px. Positive = dragging left. */
+    onDragX?: (offset: number) => void;
     /** A near-stationary press/release — a tap, not a pull. */
     onTap?: () => void;
     /**
@@ -23,10 +37,14 @@ export interface PullGestureOptions {
      * (the consumer keeps the live offset) instead of snapping back.
      */
     onSettleFree?: (direction: "up" | "down") => void;
-    /** Minimum travel (px) to count as a pull. Default 56. */
+    /** Minimum vertical travel (px) to count as a pull. Default 56. */
     distanceThreshold?: number;
-    /** Minimum speed (px/ms) to count as a flick. Default 0.5. */
+    /** Minimum vertical speed (px/ms) to count as a flick. Default 0.5. */
     velocityThreshold?: number;
+    /** Minimum horizontal travel (px) to count as a swipe. Default 64. */
+    distanceThresholdX?: number;
+    /** Minimum horizontal speed (px/ms) to count as a swipe flick. Default 0.4. */
+    velocityThresholdX?: number;
 }
 export interface PullGestureBinding {
     onPointerDown: (event: React.PointerEvent) => void;
@@ -40,5 +58,12 @@ export interface PullGestureBinding {
 }
 /** Decide whether a release should fire a pull, and in which direction. */
 export declare function resolvePull(deltaUp: number, velocityUp: number, distanceThreshold: number, velocityThreshold: number): "up" | "down" | null;
+/**
+ * Decide whether a release should fire a horizontal swipe, and in which
+ * direction. Requires horizontal dominance over the vertical travel so a
+ * mostly-vertical drag never registers as a swipe. `deltaLeft` is positive when
+ * the finger moved LEFT.
+ */
+export declare function resolveSwipe(deltaLeft: number, velocityLeft: number, deltaUp: number, distanceThresholdX: number, velocityThresholdX: number): "left" | "right" | null;
 export declare function usePullGesture(options: PullGestureOptions): PullGestureBinding;
 //# sourceMappingURL=use-pull-gesture.d.ts.map

package/components/shell/use-pull-gesture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-pull-gesture.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/use-pull-gesture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,qEAAqE;IACrE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC;IAClD,0DAA0D;IAC1D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACnD,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACnD,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACjD,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACrD;;sFAEkF;IAClF,oBAAoB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;CAC3D;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,iBAAiB,EAAE,MAAM,GACxB,IAAI,GAAG,MAAM,GAAG,IAAI,CAMtB;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,kBAAkB,GAC1B,kBAAkB,CAmFpB"}
+{"version":3,"file":"use-pull-gesture.d.ts","sourceRoot":"","sources":["../../../../../../src/components/shell/use-pull-gesture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,kFAAkF;IAClF,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC;IAClD,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sEAAsE;IACtE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,+EAA+E;IAC/E,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAOD,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACnD,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACnD,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACjD,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;IACrD;;sFAEkF;IAClF,oBAAoB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC;CAC3D;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,iBAAiB,EAAE,MAAM,GACxB,IAAI,GAAG,MAAM,GAAG,IAAI,CAMtB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,EAC1B,kBAAkB,EAAE,MAAM,GACzB,MAAM,GAAG,OAAO,GAAG,IAAI,CAQzB;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,kBAAkB,GAC1B,kBAAkB,CAiNpB"}

package/components/shell/use-pull-gesture.js

@@ -1,6 +1,8 @@
 import * as React from "react";
 /** Movement (px) under which a release is treated as a tap, not a drag. */
 const TAP_SLOP = 8;
+/** Movement (px) at which the gesture commits to a single axis. */
+const AXIS_COMMIT_SLOP = 8;
 /** Decide whether a release should fire a pull, and in which direction. */
 export function resolvePull(deltaUp, velocityUp, distanceThreshold, velocityThreshold) {
     const passed = Math.abs(deltaUp) >= distanceThreshold ||
@@ -9,45 +11,160 @@ export function resolvePull(deltaUp, velocityUp, distanceThreshold, velocityThre
         return null;
     return deltaUp > 0 ? "up" : "down";
 }
+/**
+ * Decide whether a release should fire a horizontal swipe, and in which
+ * direction. Requires horizontal dominance over the vertical travel so a
+ * mostly-vertical drag never registers as a swipe. `deltaLeft` is positive when
+ * the finger moved LEFT.
+ */
+export function resolveSwipe(deltaLeft, velocityLeft, deltaUp, distanceThresholdX, velocityThresholdX) {
+    // Horizontal must clearly dominate the vertical component.
+    if (Math.abs(deltaLeft) <= Math.abs(deltaUp))
+        return null;
+    const passed = Math.abs(deltaLeft) >= distanceThresholdX ||
+        Math.abs(velocityLeft) >= velocityThresholdX;
+    if (!passed)
+        return null;
+    return deltaLeft > 0 ? "left" : "right";
+}
 export function usePullGesture(options) {
-    const { onPullUp, onPullDown, onDrag, onTap, onSettleFree, distanceThreshold = 56, velocityThreshold = 0.5, } = options;
+    const { onPullUp, onPullDown, onDrag, onSwipeLeft, onSwipeRight, onDragX, onTap, onSettleFree, distanceThreshold = 56, velocityThreshold = 0.5, distanceThresholdX = 64, velocityThresholdX = 0.4, } = options;
+    const hasSwipe = Boolean(onSwipeLeft || onSwipeRight || onDragX);
     const start = React.useRef(null);
-    const onPointerDown = React.useCallback((event) => {
-        start.current = { y: event.clientY, t: performance.now() };
-        try {
-            event.currentTarget.setPointerCapture(event.pointerId);
+    // Which axis the gesture committed to, once it crossed AXIS_COMMIT_SLOP.
+    const axis = React.useRef(null);
+    // Coalesce the continuous drag updates to at most one per animation frame.
+    // A trackpad/touch panel emits pointermove well above the display refresh
+    // (up to ~1000Hz), and each call fans out to MotionValue subscribers (vertical
+    // sheet) or a React setState (horizontal swipe `onDragX`) — running that more
+    // than once per painted frame is pure waste (only the last value is shown).
+    // rAF-pacing matches the work to the frame the user actually sees.
+    const pendingDrag = React.useRef(null);
+    const dragRaf = React.useRef(0);
+    const onDragRef = React.useRef(onDrag);
+    const onDragXRef = React.useRef(onDragX);
+    onDragRef.current = onDrag;
+    onDragXRef.current = onDragX;
+    const flushDrag = React.useCallback(() => {
+        dragRaf.current = 0;
+        const pending = pendingDrag.current;
+        pendingDrag.current = null;
+        if (!pending)
+            return;
+        if (pending.axis === "x")
+            onDragXRef.current?.(pending.value);
+        else
+            onDragRef.current?.(pending.value);
+    }, []);
+    const scheduleDrag = React.useCallback((nextAxis, value) => {
+        pendingDrag.current = { axis: nextAxis, value };
+        if (dragRaf.current === 0 &&
+            typeof requestAnimationFrame === "function") {
+            dragRaf.current = requestAnimationFrame(flushDrag);
         }
-        catch {
-            // Detached node mid-gesture — capture is best-effort.
+    }, [flushDrag]);
+    const cancelDrag = React.useCallback(() => {
+        if (dragRaf.current !== 0 && typeof cancelAnimationFrame === "function") {
+            cancelAnimationFrame(dragRaf.current);
         }
+        dragRaf.current = 0;
+        pendingDrag.current = null;
     }, []);
+    const onPointerDown = React.useCallback((event) => {
+        start.current = {
+            x: event.clientX,
+            y: event.clientY,
+            t: performance.now(),
+        };
+        axis.current = null;
+        // When horizontal swipes are possible we DEFER capture until the gesture
+        // commits to an axis, so a vertical scroll inside the panel still scrolls
+        // natively. Pure-vertical consumers (the drag handle) capture immediately.
+        if (!hasSwipe) {
+            try {
+                event.currentTarget.setPointerCapture(event.pointerId);
+            }
+            catch {
+                // Detached node mid-gesture — capture is best-effort.
+            }
+        }
+    }, [hasSwipe]);
     const onPointerMove = React.useCallback((event) => {
         const s = start.current;
-        if (!s || !onDrag)
+        if (!s)
             return;
-        onDrag(s.y - event.clientY);
-    }, [onDrag]);
+        const dy = s.y - event.clientY; // up positive
+        const dx = s.x - event.clientX; // left positive
+        if (axis.current === null) {
+            const ax = Math.abs(dx);
+            const ay = Math.abs(dy);
+            if (Math.max(ax, ay) >= AXIS_COMMIT_SLOP) {
+                axis.current = hasSwipe && ax > ay ? "x" : "y";
+                // Take over the pointer now that intent is clear (deferred-capture path).
+                if (hasSwipe) {
+                    try {
+                        event.currentTarget.setPointerCapture(event.pointerId);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                // Reset the other axis's live offset to 0 so the committed axis owns
+                // the visual. Drop any pending pre-commit frame first so it can't
+                // override the reset on the next tick.
+                cancelDrag();
+                if (axis.current === "x")
+                    onDrag?.(0);
+                else
+                    onDragX?.(0);
+            }
+        }
+        if (axis.current === "x")
+            scheduleDrag("x", dx);
+        else if (axis.current === "y")
+            scheduleDrag("y", dy);
+        else
+            scheduleDrag("y", dy); // pre-commit: drive the vertical sheet
+    }, [hasSwipe, onDrag, onDragX, scheduleDrag, cancelDrag]);
     const finish = React.useCallback((event) => {
+        // Drop any pending coalesced drag frame so a stale value can't fire after
+        // the settle below and fight the snap.
+        cancelDrag();
         const s = start.current;
+        const committedAxis = axis.current;
         start.current = null;
+        axis.current = null;
         if (!s)
             return;
-        const deltaUp = s.y - event.clientY; // up is positive
+        const deltaUp = s.y - event.clientY; // up positive
+        const deltaLeft = s.x - event.clientX; // left positive
         const elapsed = Math.max(1, performance.now() - s.t);
         const velocityUp = deltaUp / elapsed;
-        const moved = Math.abs(deltaUp);
-        const isFlick = Math.abs(velocityUp) >= velocityThreshold;
-        // A near-stationary release is a tap (e.g. tapping the collapsed bar to
-        // focus the composer), not a drag.
-        if (moved < TAP_SLOP && !isFlick) {
-            onDrag?.(0); // snap back
+        const velocityLeft = deltaLeft / elapsed;
+        const movedY = Math.abs(deltaUp);
+        const movedX = Math.abs(deltaLeft);
+        const isFlickY = Math.abs(velocityUp) >= velocityThreshold;
+        const isFlickX = Math.abs(velocityLeft) >= velocityThresholdX;
+        // A near-stationary release (both axes) is a tap, not a drag/swipe.
+        if (movedX < TAP_SLOP && movedY < TAP_SLOP && !isFlickY && !isFlickX) {
+            onDrag?.(0);
+            onDragX?.(0);
             onTap?.();
             return;
         }
+        // Horizontal swipe path (only when the gesture committed to the X axis).
+        if (committedAxis === "x") {
+            onDragX?.(0); // settle the swipe visual
+            const swipe = resolveSwipe(deltaLeft, velocityLeft, deltaUp, distanceThresholdX, velocityThresholdX);
+            if (swipe === "left")
+                onSwipeLeft?.();
+            else if (swipe === "right")
+                onSwipeRight?.();
+            return;
+        }
         // A quick FLICK snaps to the next detent in the flick direction; any
-        // deliberate (non-flick) drag RESTS wherever it was released — drag the
-        // sheet to any size and it stays (a detent is only taken by a flick/tap).
-        if (isFlick) {
+        // deliberate (non-flick) drag RESTS wherever it was released.
+        if (isFlickY) {
             if (deltaUp > 0)
                 onPullUp?.();
             else
@@ -57,7 +174,7 @@ export function usePullGesture(options) {
         if (onSettleFree) {
             onSettleFree(deltaUp > 0 ? "up" : "down");
         }
-        else if (moved >= distanceThreshold) {
+        else if (movedY >= distanceThreshold) {
             if (deltaUp > 0)
                 onPullUp?.();
             else
@@ -67,14 +184,22 @@ export function usePullGesture(options) {
             onDrag?.(0); // sub-threshold, no free-settle consumer → snap back
         }
     }, [
+        cancelDrag,
         onDrag,
+        onDragX,
         onPullUp,
         onPullDown,
+        onSwipeLeft,
+        onSwipeRight,
         onTap,
         onSettleFree,
         distanceThreshold,
         velocityThreshold,
+        distanceThresholdX,
+        velocityThresholdX,
     ]);
+    // Cancel any in-flight coalesced frame if the consumer unmounts mid-gesture.
+    React.useEffect(() => cancelDrag, [cancelDrag]);
     return {
         onPointerDown,
         onPointerMove,

package/components/shell/usePromptSuggestions.d.ts

@@ -1,5 +1,5 @@
-import { type PageScope } from "../pages/page-scoped-conversations";
-import type { ShellMessage } from "./shell-state";
+import { type PageScope } from "../pages/page-scoped-conversations.js";
+import type { ShellMessage } from "./shell-state.js";
 /** Test-only: forget remembered/in-flight model sets so cases stay independent. */
 export declare function resetPromptSuggestionMemory(): void;
 /**
@@ -18,7 +18,7 @@ export declare function computePromptSuggestions(messages: readonly ShellMessage
 /**
  * Derive the active {@link PageScope} from the current location so the server
  * can tailor suggestions per view. The shell navigates by path or hash
- * (`/lifeops`, `#/lifeops?...`), so the first segment of whichever is present
+ * (`/browser`, `#/browser?...`), so the first segment of whichever is present
  * is the tab id; `page-<tab>` counts only when it's a registered scope. Pure
  * for unit tests; returns undefined off-DOM or on unscoped views.
  */

package/components/shell/usePromptSuggestions.js

@@ -132,7 +132,7 @@ export function computePromptSuggestions(messages, hour) {
 /**
  * Derive the active {@link PageScope} from the current location so the server
  * can tailor suggestions per view. The shell navigates by path or hash
- * (`/lifeops`, `#/lifeops?...`), so the first segment of whichever is present
+ * (`/browser`, `#/browser?...`), so the first segment of whichever is present
  * is the tab id; `page-<tab>` counts only when it's a registered scope. Pure
  * for unit tests; returns undefined off-DOM or on unscoped views.
  */