@elizaos/ui 2.0.0-beta.2 → 2.0.11-beta.7

package/state/useNavigationState.d.ts

@@ -2,11 +2,11 @@
  * Navigation state — extracted from AppContext.
  *
  * Owns: setTab wrappers, switchShellView, switchUiShellMode, setUiShellMode,
- * tab commit effects, uiShellMode persist, lastNativeTab persist,
- * tabFromPath logic, and the NavigationEventHub.
+ * deferred post-tab-commit work, uiShellMode persist, lastNativeTab persist,
+ * and tabFromPath logic.
  */
 import { type Tab } from "../navigation";
-import { type ShellView, type TabCommittedDetail, type UiShellMode } from "./internal";
+import { type ShellView, type UiShellMode } from "./internal";
 export interface NavigationStateDeps {
     tab: Tab;
     setTabRaw: (t: Tab) => void;
@@ -22,7 +22,6 @@ export declare function useNavigationState(deps: NavigationStateDeps): {
     switchUiShellMode: (mode: UiShellMode) => void;
     switchShellView: (view: ShellView) => void;
     navigation: {
-        subscribeTabCommitted: (listener: (detail: TabCommittedDetail) => void) => (() => void);
         scheduleAfterTabCommit: (fn: () => void) => void;
     };
 };

package/state/useNavigationState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNavigationState.d.ts","sourceRoot":"","sources":["../../../../../src/state/useNavigationState.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAAuC,KAAK,GAAG,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAGL,KAAK,SAAS,EAGd,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC5B,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,KAAK,IAAI,CAAC;CAChE;AAID,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB;;;qBAmB/C,GAAG;2BAsBL,WAAW;8BAoBX,WAAW;4BAeX,SAAS;;0CA8BF,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,KAC7C,CAAC,MAAM,IAAI,CAAC;qCAb6B,MAAM,IAAI;;EAqD3D"}
+{"version":3,"file":"useNavigationState.d.ts","sourceRoot":"","sources":["../../../../../src/state/useNavigationState.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAAuC,KAAK,GAAG,EAAE,MAAM,eAAe,CAAC;AAE9E,OAAO,EAGL,KAAK,SAAS,EAGd,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAqBpB,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC5B,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,KAAK,IAAI,CAAC;CAChE;AAID,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB;;;qBAmB/C,GAAG;2BAyBL,WAAW;8BAoBX,WAAW;4BAeX,SAAS;;qCAY8B,MAAM,IAAI;;EAoC3D"}

package/state/useNavigationState.js

@@ -2,14 +2,31 @@
  * Navigation state — extracted from AppContext.
  *
  * Owns: setTab wrappers, switchShellView, switchUiShellMode, setUiShellMode,
- * tab commit effects, uiShellMode persist, lastNativeTab persist,
- * tabFromPath logic, and the NavigationEventHub.
+ * deferred post-tab-commit work, uiShellMode persist, lastNativeTab persist,
+ * and tabFromPath logic.
  */
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
 import { pathForTab, shouldUseHashNavigation } from "../navigation/index.js";
+import { isNavAllowed } from "../navigation/nav-lock.js";
 import { loadLastNativeTab, normalizeUiShellMode, saveLastNativeTab, saveUiShellMode, } from "./internal.js";
-import { NavigationEventHub } from "./navigation-events.js";
 import { getTabForShellView } from "./shell-routing.js";
+function pathWithCurrentShellMode(path) {
+    if (typeof window === "undefined")
+        return path;
+    const html = window.document?.documentElement;
+    const body = window.document?.body;
+    const isDetachedShell = html?.classList.contains("eliza-chat-overlay-shell") === true ||
+        body?.classList.contains("eliza-chat-overlay-shell") === true;
+    if (!isDetachedShell)
+        return path;
+    const params = new URLSearchParams(window.location.search);
+    const shellMode = params.get("shellMode") ?? params.get("shell-mode");
+    if (!shellMode)
+        return path;
+    const nextParams = new URLSearchParams();
+    nextParams.set("shellMode", shellMode);
+    return `${path}?${nextParams.toString()}`;
+}
 // ── Hook ──────────────────────────────────────────────────────────────────
 export function useNavigationState(deps) {
     const { tab, setTabRaw, uiShellMode, hasActiveGameRun, setAppsSubTab } = deps;
@@ -23,6 +40,10 @@ export function useNavigationState(deps) {
     }, [lastNativeTab]);
     // ── setTab (with URL sync) ──────────────────────────────────────────
     const setTab = useCallback((newTab) => {
+        // A guided flow (the tour) can restrict navigation to the tabs the current
+        // step expects, so nothing drifts the app into a state it doesn't expect.
+        if (!isNavAllowed(newTab))
+            return;
         setTabRaw(newTab);
         if (newTab === "apps") {
             setAppsSubTab(hasActiveGameRun ? "games" : "browse");
@@ -33,11 +54,11 @@ export function useNavigationState(deps) {
                 window.location.hash = path;
             }
             else {
-                window.history.pushState(null, "", path);
+                window.history.pushState(null, "", pathWithCurrentShellMode(path));
             }
         }
-        catch (err) {
-            console.warn("[eliza][nav] failed to update browser location", err);
+        catch {
+            // non-fatal: browser history update fails in restricted environments
         }
     }, [hasActiveGameRun, setTabRaw, setAppsSubTab]);
     // ── Shell mode toggles ──────────────────────────────────────────────
@@ -69,15 +90,11 @@ export function useNavigationState(deps) {
     }, [lastNativeTab, setTab, uiShellMode]);
     const switchShellView = useCallback((view) => {
         const nextTab = getTabForShellView(view, lastNativeTab);
-        console.log(`[shell] switchShellView: ${view} → tab=${nextTab}, lastNativeTab=${lastNativeTab}`);
         setTab(nextTab);
     }, [lastNativeTab, setTab]);
-    // ── Tab commit events ───────────────────────────────────────────────
-    const navigationHubRef = useRef(new NavigationEventHub());
+    // ── Deferred post-tab-commit work ───────────────────────────────────
     const pendingPostTabCommitRef = useRef([]);
-    const prevTabCommittedRef = useRef(null);
-    const prevUiShellCommittedRef = useRef(null);
-    const [_tabCommitFlushNonce, setTabCommitFlushNonce] = useState(0);
+    const [tabCommitFlushNonce, setTabCommitFlushNonce] = useState(0);
     const scheduleAfterTabCommit = useCallback((fn) => {
         pendingPostTabCommitRef.current.push(fn);
         if (pendingPostTabCommitRef.current.length === 1) {
@@ -86,30 +103,20 @@ export function useNavigationState(deps) {
             });
         }
     }, []);
-    const navigation = useMemo(() => ({
-        subscribeTabCommitted: (listener) => navigationHubRef.current.subscribe(listener),
-        scheduleAfterTabCommit,
-    }), [scheduleAfterTabCommit]);
+    const navigation = useMemo(() => ({ scheduleAfterTabCommit }), [scheduleAfterTabCommit]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: tab/uiShellMode/tabCommitFlushNonce are intentional triggers — the flush must run after each tab/shell layout commit and after scheduleAfterTabCommit bumps the nonce.
     useLayoutEffect(() => {
-        const tabChanged = prevTabCommittedRef.current !== tab;
-        const shellChanged = prevUiShellCommittedRef.current !== uiShellMode;
         const pending = pendingPostTabCommitRef.current;
         pendingPostTabCommitRef.current = [];
-        if (tabChanged || shellChanged) {
-            const previousTab = prevTabCommittedRef.current;
-            prevTabCommittedRef.current = tab;
-            prevUiShellCommittedRef.current = uiShellMode;
-            navigationHubRef.current.emit({ tab, previousTab, uiShellMode });
-        }
         for (const task of pending) {
             try {
                 task();
             }
-            catch (err) {
-                console.warn("[eliza][navigation] scheduleAfterTabCommit task failed", err);
+            catch {
+                // task errors must not block remaining scheduled work
             }
         }
-    }, [tab, uiShellMode]);
+    }, [tab, uiShellMode, tabCommitFlushNonce]);
     return {
         lastNativeTab,
         setLastNativeTabState,

package/state/usePluginsSkillsState.d.ts

@@ -101,8 +101,8 @@ export declare function usePluginsSkillsState({ setActionNotice, setPendingResta
     setStorePlugins: import("react").Dispatch<import("react").SetStateAction<RegistryPlugin[]>>;
     storeSearch: string;
     setStoreSearch: import("react").Dispatch<import("react").SetStateAction<string>>;
-    storeFilter: "installed" | "all" | "ai-provider" | "connector" | "feature";
-    setStoreFilter: import("react").Dispatch<import("react").SetStateAction<"installed" | "all" | "ai-provider" | "connector" | "feature">>;
+    storeFilter: "all" | "installed" | "ai-provider" | "connector" | "feature";
+    setStoreFilter: import("react").Dispatch<import("react").SetStateAction<"all" | "installed" | "ai-provider" | "connector" | "feature">>;
     storeLoading: boolean;
     setStoreLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     storeInstalling: Set<string>;

package/state/usePluginsSkillsState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePluginsSkillsState.d.ts","sourceRoot":"","sources":["../../../../../src/state/usePluginsSkillsState.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,QAAQ,CAAC;AAyBhB;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,CAAC,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,EAC7C,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAOrC;AAED,UAAU,wBAAwB;IAChC,eAAe,EAAE,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,EACnC,KAAK,CAAC,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,OAAO,KACX,IAAI,CAAC;IACV,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3E,wBAAwB,EAAE,CACxB,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,KAC7C,IAAI,CAAC;IACV,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAID,wBAAgB,qBAAqB,CAAC,EACpC,eAAe,EACf,iBAAiB,EACjB,wBAAwB,EACxB,iBAAiB,EACjB,cAAc,GACf,EAAE,wBAAwB;;;;;;;;;;;;;;;;;6BAyFyB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;oCAWnD;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE;mCAQrB,MAAM,WAAW,OAAO;uCAyExB,MAAM,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA+HvC,MAAM,WAAW,OAAO;;+BAwDxB,MAAM;iCAgBN,MAAM,aAAa,MAAM;iCAyBW,MAAM;sCAe1C,MAAM;;wCAgDT,sBAAsB;;yCAwEnB,MAAM,QAAQ,MAAM;sCAoBpB,MAAM,QAAQ,MAAM;uCAoBpB,MAAM,QAAQ,MAAM;0CAoBpB,MAAM,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgJvC"}
+{"version":3,"file":"usePluginsSkillsState.d.ts","sourceRoot":"","sources":["../../../../../src/state/usePluginsSkillsState.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,QAAQ,CAAC;AAyBhB;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,CAAC,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,EAC7C,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAOrC;AAED,UAAU,wBAAwB;IAChC,eAAe,EAAE,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,EACnC,KAAK,CAAC,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,OAAO,KACX,IAAI,CAAC;IACV,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3E,wBAAwB,EAAE,CACxB,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,KAC7C,IAAI,CAAC;IACV,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAID,wBAAgB,qBAAqB,CAAC,EACpC,eAAe,EACf,iBAAiB,EACjB,wBAAwB,EACxB,iBAAiB,EACjB,cAAc,GACf,EAAE,wBAAwB;;;;;;;;;;;;;;;;;6BAyFyB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;oCAiBnD;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE;mCASrB,MAAM,WAAW,OAAO;uCAyExB,MAAM,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8HvC,MAAM,WAAW,OAAO;;+BAwDxB,MAAM;iCAgBN,MAAM,aAAa,MAAM;iCAyBW,MAAM;sCAe1C,MAAM;;wCAgDT,sBAAsB;;yCAwEnB,MAAM,QAAQ,MAAM;sCAoBpB,MAAM,QAAQ,MAAM;uCAoBpB,MAAM,QAAQ,MAAM;0CAoBpB,MAAM,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgJvC"}

package/state/usePluginsSkillsState.js

@@ -6,9 +6,9 @@
  *
  * Accepts `{ setActionNotice }` for cross-domain notifications.
  */
-import { useCallback, useState } from "react";
+import { useCallback, useRef, useState } from "react";
 import { client, } from "../api/index.js";
-import { normalizeOnboardingProviderId } from "../providers/index.js";
+import { normalizeFirstRunProviderId } from "../providers/index.js";
 import { confirmDesktopAction } from "../utils/index.js";
 // ── Types ──────────────────────────────────────────────────────────────
 /**
@@ -107,11 +107,18 @@ export function usePluginsSkillsState({ setActionNotice, setPendingRestart, setP
             /* ignore */
         }
     }, []);
+    // Read pluginsLoaded through a ref so this callback keeps a stable identity.
+    // Putting pluginsLoaded in the deps made the callback (and therefore the
+    // whole AppContext value) bust the moment the first load flipped the flag,
+    // re-rendering every useApp() consumer on boot.
+    const pluginsLoadedRef = useRef(pluginsLoaded);
+    pluginsLoadedRef.current = pluginsLoaded;
     const ensurePluginsLoaded = useCallback(async (options) => {
-        if (pluginsLoaded && !options?.refresh)
+        const alreadyLoaded = pluginsLoadedRef.current;
+        if (alreadyLoaded && !options?.refresh)
             return;
-        await loadPlugins(pluginsLoaded ? { silent: true } : undefined);
-    }, [loadPlugins, pluginsLoaded]);
+        await loadPlugins(alreadyLoaded ? { silent: true } : undefined);
+    }, [loadPlugins]);
     const handlePluginToggle = useCallback(async (pluginId, enabled) => {
         const plugin = plugins.find((p) => p.id === pluginId);
         const pluginName = plugin?.name ?? pluginId;
@@ -171,7 +178,7 @@ export function usePluginsSkillsState({ setActionNotice, setPendingRestart, setP
             // When saving an AI provider's API key, also trigger a provider
             // switch so the runtime restarts with the new plugin loaded.
             if (isAiProvider) {
-                const providerId = normalizeOnboardingProviderId(pluginId) ?? pluginId;
+                const providerId = normalizeFirstRunProviderId(pluginId) ?? pluginId;
                 // Identify the primary credential field by its STRUCTURE, not
                 // by iterating values. The plugin's parameter metadata
                 // declares which fields are sensitive; the picker walks a

package/state/useStartupCoordinator.d.ts

@@ -18,6 +18,9 @@ import { type HydratingDeps, type ReadyPhaseDeps } from "./startup-phase-hydrate
 import { type PollingBackendDeps } from "./startup-phase-poll";
 import { type RestoringSessionDeps } from "./startup-phase-restore";
 import { type StartingRuntimeDeps } from "./startup-phase-runtime";
+export declare function recoverTerminalStartupError(deps: StartupCoordinatorDeps, dispatch: (event: StartupEvent) => void, cancelled: {
+    current: boolean;
+}): Promise<boolean>;
 export type StartupCoordinatorDeps = RestoringSessionDeps & PollingBackendDeps & StartingRuntimeDeps & HydratingDeps & ReadyPhaseDeps & {
     /** Legacy lifecycle setter — driven by the coordinator sync effect. */
     setStartupPhase: (v: "starting-backend" | "initializing-agent" | "ready") => void;
@@ -28,7 +31,7 @@ export interface StartupCoordinatorHandle {
     retry: () => void;
     reset: () => void;
     pairingSuccess: () => void;
-    onboardingComplete: () => void;
+    firstRunComplete: () => void;
     policy: PlatformPolicy;
     legacyPhase: "starting-backend" | "initializing-agent" | "ready";
     loading: boolean;

package/state/useStartupCoordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStartupCoordinator.d.ts","sourceRoot":"","sources":["../../../../../src/state/useStartupCoordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EASL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,YAAY,EAGlB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AAMjC,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,GACvD,kBAAkB,GAClB,mBAAmB,GACnB,aAAa,GACb,cAAc,GAAG;IACf,uEAAuE;IACvE,eAAe,EAAE,CACf,CAAC,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,OAAO,KACnD,IAAI,CAAC;CACX,CAAC;AAIJ,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,WAAW,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,OAAO,CAAC;IACjE,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;CAC9B;AAeD,wBAAgB,qBAAqB,CACnC,IAAI,CAAC,EAAE,sBAAsB,GAC5B,wBAAwB,CA2L1B"}
+{"version":3,"file":"useStartupCoordinator.d.ts","sourceRoot":"","sources":["../../../../../src/state/useStartupCoordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,EAUL,KAAK,cAAc,EACnB,KAAK,aAAa,EAElB,KAAK,YAAY,EACjB,KAAK,YAAY,EAGlB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AAoBjC,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,sBAAsB,EAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,EACvC,SAAS,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAC9B,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAMD,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,GACvD,kBAAkB,GAClB,mBAAmB,GACnB,aAAa,GACb,cAAc,GAAG;IACf,uEAAuE;IACvE,eAAe,EAAE,CACf,CAAC,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,OAAO,KACnD,IAAI,CAAC;CACX,CAAC;AAIJ,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,WAAW,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,OAAO,CAAC;IACjE,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;CAC9B;AAgBD,wBAAgB,qBAAqB,CACnC,IAAI,CAAC,EAAE,sBAAsB,GAC5B,wBAAwB,CA+O1B"}

package/state/useStartupCoordinator.js

@@ -13,15 +13,63 @@
  * Persistent WS bindings and navigation listeners are set up via bindReadyPhase
  * in a "ready" effect that only cleans up on unmount (not on phase transitions).
  */
+import { logger } from "@elizaos/logger";
 import { useCallback, useEffect, useReducer, useRef } from "react";
+import { client } from "../api/index.js";
 import { isElectrobunRuntime } from "../bridge/index.js";
-import { isAndroid, isElizaOS, isNative } from "../platform/index.js";
-import { loadPersistedOnboardingComplete } from "./persistence.js";
-import { createAndroidPolicy, createDesktopPolicy, createElizaOSPolicy, createMobilePolicy, createWebPolicy, INITIAL_STARTUP_STATE, isStartupLoading, isStartupTerminal, startupReducer, toLegacyStartupPhase, } from "./startup-coordinator.js";
+import { isAndroid, isElizaOS, isIOS, isNative } from "../platform/index.js";
+import { createAndroidPolicy, createDesktopPolicy, createElizaOSPolicy, createIosPolicy, createMobilePolicy, createWebPolicy, INITIAL_STARTUP_STATE, isStartupLoading, isStartupTerminal, startupReducer, toLegacyStartupPhase, } from "./startup-coordinator.js";
 import { bindReadyPhase, runHydrating, } from "./startup-phase-hydrate.js";
 import { runPollingBackend, } from "./startup-phase-poll.js";
 import { runRestoringSession, } from "./startup-phase-restore.js";
 import { runStartingRuntime, } from "./startup-phase-runtime.js";
+// Auto-recovery backoff: probe the backend after a transient startup error,
+// backing off 2.5s → 5s → 10s → 20s → cap 30s, and give up after a bounded
+// number of attempts so a genuinely-down backend stops thrashing and the user
+// falls back to the manual Retry button.
+const RECOVERY_BASE_DELAY_MS = 2_500;
+const RECOVERY_MAX_DELAY_MS = 30_000;
+const RECOVERY_MAX_ATTEMPTS = 8;
+function isRecoverableStartupErrorReason(reason) {
+    return (reason === "backend-timeout" ||
+        reason === "backend-unreachable" ||
+        reason === "agent-timeout" ||
+        reason === "agent-error" ||
+        reason === "unknown");
+}
+export async function recoverTerminalStartupError(deps, dispatch, cancelled) {
+    let status;
+    try {
+        status = await client.getStatus();
+    }
+    catch {
+        return false;
+    }
+    if (cancelled.current || status.state !== "running")
+        return false;
+    let firstRunComplete = deps.firstRunCompletionCommittedRef.current;
+    try {
+        const firstRunStatus = await client.getFirstRunStatus();
+        firstRunComplete = firstRunComplete || firstRunStatus.complete === true;
+    }
+    catch {
+        return false;
+    }
+    if (cancelled.current)
+        return false;
+    deps.setAgentStatus(status);
+    deps.setConnected(true);
+    deps.setStartupError(null);
+    deps.setFirstRunLoading(false);
+    deps.setFirstRunComplete(firstRunComplete);
+    if (firstRunComplete) {
+        dispatch({ type: "AGENT_RUNNING" });
+    }
+    else {
+        dispatch({ type: "BACKEND_REACHED", firstRunComplete: false });
+    }
+    return true;
+}
 function detectPlatformPolicy() {
     if (isElectrobunRuntime())
         return createDesktopPolicy();
@@ -32,6 +80,8 @@ function detectPlatformPolicy() {
         return createElizaOSPolicy();
     if (isAndroid)
         return createAndroidPolicy();
+    if (isIOS)
+        return createIosPolicy();
     if (isNative)
         return createMobilePolicy();
     return createWebPolicy();
@@ -56,19 +106,6 @@ export function useStartupCoordinator(deps) {
             return;
         depsRef.current?.setStartupPhase(legacyPhase);
     }, [legacyPhase, depsReady]);
-    // ── Phase: splash — auto-skip for returning users, mark loaded for new users
-    // Fresh installs stay on splash until the user explicitly continues.
-    useEffect(() => {
-        if (state.phase !== "splash")
-            return;
-        if (!depsReady)
-            return;
-        if (loadPersistedOnboardingComplete()) {
-            dispatch({ type: "SPLASH_CONTINUE" });
-            return;
-        }
-        dispatch({ type: "SPLASH_LOADED" });
-    }, [state.phase, depsReady]);
     // ── Phase: restoring-session ────────────────────────────────────
     useEffect(() => {
         if (state.phase !== "restoring-session" || !depsReady)
@@ -78,9 +115,7 @@ export function useStartupCoordinator(deps) {
             return;
         effectRunRef.current += 1;
         const cancelled = { current: false };
-        runRestoringSession(d, dispatch, _ctx, cancelled).catch((err) => {
-            console.error("[eliza][startup:restore] Unexpected error:", err);
-        });
+        runRestoringSession(d, dispatch, _ctx, cancelled).catch(() => { });
         return () => {
             cancelled.current = true;
         };
@@ -102,9 +137,7 @@ export function useStartupCoordinator(deps) {
         const runId = effectRunRef.current;
         const cancelled = { current: false };
         const tidRef = { current: null };
-        runPollingBackend(currentDeps, dispatch, policy, _ctx.current, runId, effectRunRef, cancelled, tidRef).catch((err) => {
-            console.error("[eliza][startup:poll] Unexpected error:", err);
-        });
+        runPollingBackend(currentDeps, dispatch, policy, _ctx.current, runId, effectRunRef, cancelled, tidRef).catch(() => { });
         return () => {
             cancelled.current = true;
             if (tidRef.current)
@@ -112,19 +145,23 @@ export function useStartupCoordinator(deps) {
         };
     }, [state.phase, policy.backendTimeoutMs, depsReady, policy]);
     // ── Phase: starting-runtime ─────────────────────────────────────
+    // The runtime target is fixed for a given starting-runtime entry (it is
+    // carried in the state object and never mutates in place), so re-running on
+    // `state.phase` alone already picks up the correct target. The local
+    // primitive keeps it readable inside the effect without widening the deps.
+    const startingRuntimeTarget = state.phase === "starting-runtime" ? state.target : null;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: startingRuntimeTarget is constant across a single starting-runtime entry; state.phase is the real trigger.
     useEffect(() => {
         if (state.phase !== "starting-runtime" || !depsReady)
             return;
         const currentDeps = depsRef.current;
-        if (!currentDeps)
+        if (!currentDeps || !startingRuntimeTarget)
             return;
         effectRunRef.current += 1;
         const runId = effectRunRef.current;
         const cancelled = { current: false };
         const tidRef = { current: null };
-        runStartingRuntime(currentDeps, dispatch, runId, effectRunRef, cancelled, tidRef).catch((err) => {
-            console.error("[eliza][startup:runtime] Unexpected error:", err);
-        });
+        runStartingRuntime(currentDeps, dispatch, runId, effectRunRef, cancelled, tidRef, startingRuntimeTarget).catch(() => { });
         return () => {
             cancelled.current = true;
             if (tidRef.current)
@@ -140,7 +177,13 @@ export function useStartupCoordinator(deps) {
             return;
         const cancelled = { current: false };
         runHydrating(currentDeps, dispatch, cancelled).catch((err) => {
-            console.error("[eliza][startup:hydrate] Unexpected error:", err);
+            // Hydration decorates the shell (wallet, avatar, autonomy replay…);
+            // everything past conversation restore is best-effort. Completing with
+            // partial data beats stranding the composer in "connecting" forever —
+            // and the reducer no-ops HYDRATION_COMPLETE outside "hydrating", so
+            // this can only ever unlock a stalled boot, never mis-transition.
+            logger.warn(`[eliza][startup:init] hydration failed; completing with partial data: ${err instanceof Error ? err.message : String(err)}`);
+            dispatch({ type: "HYDRATION_COMPLETE" });
         });
         return () => {
             cancelled.current = true;
@@ -163,6 +206,57 @@ export function useStartupCoordinator(deps) {
             cleanup();
         };
     }, [readyPhaseReached, depsReady]);
+    // Desktop cold starts can briefly report an agent failure while the embedded
+    // runtime is still settling, especially when the renderer loads before the
+    // health/status routes are ready. Once the backend later reports a running
+    // agent, recover automatically instead of leaving the user stuck on the
+    // startup failure card until they manually press Retry.
+    const errorReason = state.phase === "error" ? state.reason : null;
+    useEffect(() => {
+        if (state.phase !== "error" || !depsReady)
+            return;
+        if (!errorReason || !isRecoverableStartupErrorReason(errorReason))
+            return;
+        if (typeof window === "undefined")
+            return;
+        const currentDeps = depsRef.current;
+        if (!currentDeps)
+            return;
+        const cancelled = { current: false };
+        // Schedule probes with exponential backoff (2.5s → cap 30s) and stop after
+        // a fixed number of attempts. Depending on `[state, ...]` here would
+        // re-arm this loop on every dispatch (each mints a new state object),
+        // turning a degraded backend into a perpetual probe storm that re-renders
+        // every useApp() consumer. Gate on the specific primitives the effect uses;
+        // other state fields are read through depsRef when a probe fires.
+        let timer = 0;
+        let attempt = 0;
+        const scheduleNext = () => {
+            if (cancelled.current || attempt >= RECOVERY_MAX_ATTEMPTS)
+                return;
+            const delay = Math.min(RECOVERY_BASE_DELAY_MS * 2 ** attempt, RECOVERY_MAX_DELAY_MS);
+            attempt += 1;
+            timer = window.setTimeout(() => {
+                void recoverTerminalStartupError(currentDeps, dispatch, cancelled)
+                    .then((recovered) => {
+                    // On success the dispatched event transitions out of "error", which
+                    // tears down this effect. Otherwise keep probing under backoff until
+                    // the attempt cap is reached, leaving the user-actionable Retry path.
+                    if (!recovered)
+                        scheduleNext();
+                })
+                    .catch(() => {
+                    scheduleNext();
+                });
+            }, delay);
+        };
+        scheduleNext();
+        return () => {
+            cancelled.current = true;
+            if (timer)
+                window.clearTimeout(timer);
+        };
+    }, [state.phase, errorReason, depsReady]);
     // ── Public interface ─────────────────────────────────────────────
     const retry = useCallback(() => dispatch({ type: "RETRY" }), []);
     const reset = useCallback(() => {
@@ -171,19 +265,21 @@ export function useStartupCoordinator(deps) {
         dispatch({ type: "RESET" });
     }, []);
     const pairingSuccess = useCallback(() => dispatch({ type: "PAIRING_SUCCESS" }), []);
-    const onboardingCompleteFn = useCallback(() => dispatch({ type: "ONBOARDING_COMPLETE" }), []);
+    const firstRunCompleteFn = useCallback(() => dispatch({ type: "FIRST_RUN_COMPLETE" }), []);
     let target = null;
     if (state.phase === "resolving-target")
         target = state.target;
     else if (state.phase === "polling-backend")
         target = state.target;
+    else if (state.phase === "starting-runtime")
+        target = state.target;
     return {
         state,
         dispatch,
         retry,
         reset,
         pairingSuccess,
-        onboardingComplete: onboardingCompleteFn,
+        firstRunComplete: firstRunCompleteFn,
         policy,
         legacyPhase: toLegacyStartupPhase(state),
         loading: isStartupLoading(state),

package/state/useStreamingText.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Streaming-text primitive for the chat reducer.
+ *
+ * The chat pipeline only ever does six things to an in-flight assistant
+ * turn while a stream is alive:
+ *
+ *   - append a token (delta)        → mode: "append"
+ *   - replace text from a snapshot  → mode: "replace"
+ *   - apply final reconciled text   → mode: "complete"
+ *   - stamp a server failureKind    → mode: "fail"
+ *   - mark the turn as interrupted  → mode: "interrupt"
+ *   - drop an empty assistant turn  → mode: "drop"
+ *
+ * Every one of those used to be a hand-rolled `setMessages(prev => prev.map(...))`
+ * with subtly different equality checks scattered across `useChatSend.ts`
+ * and `useChatCallbacks.ts`. This primitive collapses them into a single
+ * map pass that:
+ *
+ *   - matches the target message by id,
+ *   - returns the previous array unchanged when the modification produces
+ *     no observable delta (referential equality preserved → no re-render),
+ *   - supports the same updater-fn semantics as React's `setState`.
+ *
+ * It deliberately does nothing structural (no inserts, no reorders) — those
+ * stay as direct `setConversationMessages` calls.
+ */
+import type { Dispatch, SetStateAction } from "react";
+import type { ChatFailureKind, ConversationMessage } from "../api";
+export type StreamingTextSetter = Dispatch<SetStateAction<ConversationMessage[]>>;
+/**
+ * One streaming-text mutation against a single in-flight assistant turn.
+ *
+ * `messageId` always identifies the assistant turn being modified. All other
+ * fields are mode-specific.
+ */
+export type StreamingTextModification = {
+    messageId: string;
+    mode: "append";
+    /** Raw delta token from the SSE stream. */
+    token: string;
+} | {
+    messageId: string;
+    mode: "replace";
+    /** Cumulative snapshot text from the SSE stream. */
+    fullText: string;
+} | {
+    messageId: string;
+    mode: "complete";
+    /** Final reconciled assistant text from the server. */
+    fullText: string;
+    /** Optional server-flagged failure class to stamp alongside the text. */
+    failureKind?: ChatFailureKind;
+    /** Optional agent reasoning/thought to stamp on the completed turn. */
+    reasoning?: string;
+} | {
+    messageId: string;
+    mode: "fail";
+    /** Server-flagged failure class. Text is left untouched. */
+    failureKind: ChatFailureKind;
+} | {
+    messageId: string;
+    mode: "interrupt";
+} | {
+    messageId: string;
+    mode: "drop";
+};
+/**
+ * Apply one streaming-text modification to the chat-message reducer.
+ *
+ * Returns referentially-equal `prev` when the modification is a no-op
+ * (target id missing, text already matches, failureKind already set, etc.).
+ */
+export declare function applyStreamingTextModification(setMessages: StreamingTextSetter, mod: StreamingTextModification): void;
+//# sourceMappingURL=useStreamingText.d.ts.map

package/state/useStreamingText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamingText.d.ts","sourceRoot":"","sources":["../../../../../src/state/useStreamingText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAGnE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CACxC,cAAc,CAAC,mBAAmB,EAAE,CAAC,CACtC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf,GACD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,CAAC;IACjB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,WAAW,EAAE,eAAe,CAAC;CAC9B,GACD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,WAAW,CAAC;CACnB,GACD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqDN;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,mBAAmB,EAChC,GAAG,EAAE,yBAAyB,GAC7B,IAAI,CAiBN"}